/* Authors: Karl MacMillan <kmacmillan@tresys.com>

 *	    Joshua Brindle <jbrindle@tresys.com>

 *	    Jason Tang <jtang@tresys.com>

 *          Christopher Ashworth <cashworth@tresys.com>

 *          Chris PeBenito <cpebenito@tresys.com>

 *	    Caleb Case <ccase@tresys.com>

 *

 * Copyright (C) 2004-2006,2009 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

 */

/* This file contains semanage routines that manipulate the files on a

 * local module store.	Sandbox routines, used by both source and

 * direct connections, are here as well.

 */

struct dbase_policydb;

typedef struct dbase_policydb dbase_t;

#define DBASE_DEFINED

#include "semanage_store.h"

#include "database_policydb.h"

#include "handle.h"

#include <selinux/selinux.h>

#include <sepol/policydb.h>

#include <sepol/module.h>

#include <assert.h>

#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdio_ext.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <limits.h>

#include <libgen.h>

#include "debug.h"

#include "utilities.h"

#define SEMANAGE_CONF_FILE "semanage.conf"

/* relative path names to enum semanage_paths to special files and

 * directories for the module store */

#define TRUE 1

enum semanage_file_defs {

	SEMANAGE_ROOT,

	SEMANAGE_TRANS_LOCK,

	SEMANAGE_READ_LOCK,

	SEMANAGE_NUM_FILES

};

static char *semanage_paths[SEMANAGE_NUM_STORES][SEMANAGE_STORE_NUM_PATHS];

static char *semanage_files[SEMANAGE_NUM_FILES] = { NULL };

static int semanage_paths_initialized = 0;

/* These are paths relative to the bottom of the module store */

static const char *semanage_relative_files[SEMANAGE_NUM_FILES] = {

	"",

	"/semanage.trans.LOCK",

	"/semanage.read.LOCK"

};

static const char *semanage_store_paths[SEMANAGE_NUM_STORES] = {

	"/active",

	"/previous",

	"/tmp"

};

/* relative path names to enum sandbox_paths for special files within

 * a sandbox */

static const char *semanage_sandbox_paths[SEMANAGE_STORE_NUM_PATHS] = {

	"",

	"/modules",

	"/policy.linked",

	"/homedir_template",

	"/file_contexts.template",

	"/commit_num",

	"/pkeys.local",

	"/ibendports.local",

	"/ports.local",

	"/interfaces.local",

	"/nodes.local",

	"/booleans.local",

	"/seusers.local",

	"/seusers.linked",

	"/users.local",

	"/users_extra.local",

	"/users_extra.linked",

	"/users_extra",

	"/disable_dontaudit",

	"/preserve_tunables",

	"/modules/disabled",

	"/policy.kern",

	"/file_contexts.local",

	"/file_contexts.homedirs",

	"/file_contexts",

	"/seusers"

};

static char const * const semanage_final_prefix[SEMANAGE_FINAL_NUM] = {

	"/final",

	"",

};

static char *semanage_final[SEMANAGE_FINAL_NUM] = { NULL };

static char *semanage_final_suffix[SEMANAGE_FINAL_PATH_NUM] = { NULL };

static char *semanage_final_paths[SEMANAGE_FINAL_NUM][SEMANAGE_FINAL_PATH_NUM] = {{ NULL }};

/* A node used in a linked list of file contexts; used for sorting.

 */

typedef struct semanage_file_context_node {

	char *path;

	char *file_type;

	char *context;

	int path_len;

	int effective_len;

	int type_len;

	int context_len;

	int meta;		/* position of first meta char in path, -1 if none */

	struct semanage_file_context_node *next;

} semanage_file_context_node_t;

/* A node used in a linked list of buckets that contain

 *  semanage_file_context_node lists.  Used for sorting.

 */

typedef struct semanage_file_context_bucket {

	semanage_file_context_node_t *data;

	struct semanage_file_context_bucket *next;

} semanage_file_context_bucket_t;

/* A node used in a linked list of netfilter rules.

 */

typedef struct semanage_netfilter_context_node {

	char *rule;

	size_t rule_len;

	struct semanage_netfilter_context_node *next;

} semanage_netfilter_context_node_t;

/* Initialize the paths to config file, lock files and store root.

 */

static int semanage_init_paths(const char *root)

{

	size_t len, prefix_len;

	int i;

	if (!root)

		return -1;

	prefix_len = strlen(root);

	for (i = 0; i < SEMANAGE_NUM_FILES; i++) {

		len = (strlen(semanage_relative_files[i]) + prefix_len);

		semanage_files[i] = calloc(len + 1, sizeof(char));

		if (!semanage_files[i])

			return -1;

		sprintf(semanage_files[i], "%s%s", root,

			semanage_relative_files[i]);

	}

	return 0;

}

/* This initializes the paths inside the stores, this is only necessary 

 * when directly accessing the store

 */

static int semanage_init_store_paths(const char *root)

{

	int i, j;

	size_t len;

	size_t prefix_len;

	if (!root)

		return -1;

	prefix_len = strlen(root);

	for (i = 0; i < SEMANAGE_NUM_STORES; i++) {

		for (j = 0; j < SEMANAGE_STORE_NUM_PATHS; j++) {

			len = prefix_len + strlen(semanage_store_paths[i])

			    + strlen(semanage_sandbox_paths[j]);

			semanage_paths[i][j] = calloc(len + 1, sizeof(char));

			if (!semanage_paths[i][j])

				goto cleanup;

			sprintf(semanage_paths[i][j], "%s%s%s", root,

				semanage_store_paths[i],

				semanage_sandbox_paths[j]);

		}

	}

      cleanup:

	return 0;

}

static int semanage_init_final(semanage_handle_t *sh, const char *prefix)

{

	assert(sh);

	assert(prefix);

	int status = 0;

	size_t len;

	const char *store_path = sh->conf->store_path;

	size_t store_len = strlen(store_path);

	/* SEMANAGE_FINAL_TMP */

	len = strlen(semanage_root()) +

	      strlen(prefix) +

	      strlen("/") +

	      strlen(semanage_final_prefix[SEMANAGE_FINAL_TMP]) +

	      store_len;

	semanage_final[SEMANAGE_FINAL_TMP] = malloc(len + 1);

	if (semanage_final[SEMANAGE_FINAL_TMP] == NULL) {

		status = -1;

		goto cleanup;

	}

	sprintf(semanage_final[SEMANAGE_FINAL_TMP],

		"%s%s%s/%s",

		semanage_root(),

		prefix,

		semanage_final_prefix[SEMANAGE_FINAL_TMP],

		store_path);

	/* SEMANAGE_FINAL_SELINUX */

	const char *selinux_root = selinux_path();

	len = strlen(semanage_root()) +

	      strlen(selinux_root) +

	      strlen(semanage_final_prefix[SEMANAGE_FINAL_SELINUX]) +

	      store_len;

	semanage_final[SEMANAGE_FINAL_SELINUX] = malloc(len + 1);

	if (semanage_final[SEMANAGE_FINAL_SELINUX] == NULL) {

		status = -1;

		goto cleanup;

	}

	sprintf(semanage_final[SEMANAGE_FINAL_SELINUX],

		"%s%s%s%s",

		semanage_root(),

		selinux_root,

		semanage_final_prefix[SEMANAGE_FINAL_SELINUX],

		store_path);

cleanup:

	if (status != 0) {

		int i;

		for (i = 0; i < SEMANAGE_FINAL_NUM; i++) {

			free(semanage_final[i]);

			semanage_final[i] = NULL;

		}

	}

	return status;

}

static int semanage_init_final_suffix(semanage_handle_t *sh)

{

	int ret = 0;

	int status = 0;

	char path[PATH_MAX];

	size_t offset = strlen(selinux_policy_root());

	semanage_final_suffix[SEMANAGE_FINAL_TOPLEVEL] = strdup("");

	if (semanage_final_suffix[SEMANAGE_FINAL_TOPLEVEL] == NULL) {

		ERR(sh, "Unable to allocate space for policy top level path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_FC] =

		strdup(selinux_file_context_path() + offset);

	if (semanage_final_suffix[SEMANAGE_FC] == NULL) {

		ERR(sh, "Unable to allocate space for file context path.");

		status = -1;

		goto cleanup;

	}

	if (asprintf(&semanage_final_suffix[SEMANAGE_FC_BIN], "%s.bin",

		     semanage_final_suffix[SEMANAGE_FC]) < 0) {

		ERR(sh, "Unable to allocate space for file context path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_FC_HOMEDIRS] =

		strdup(selinux_file_context_homedir_path() + offset);

	if (semanage_final_suffix[SEMANAGE_FC_HOMEDIRS] == NULL) {

		ERR(sh, "Unable to allocate space for file context home directory path.");

		status = -1;

		goto cleanup;

	}

	if (asprintf(&semanage_final_suffix[SEMANAGE_FC_HOMEDIRS_BIN], "%s.bin",

		     semanage_final_suffix[SEMANAGE_FC_HOMEDIRS]) < 0) {

		ERR(sh, "Unable to allocate space for file context home directory path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_FC_LOCAL] =

		strdup(selinux_file_context_local_path() + offset);

	if (semanage_final_suffix[SEMANAGE_FC_LOCAL] == NULL) {

		ERR(sh, "Unable to allocate space for local file context path.");

		status = -1;

		goto cleanup;

	}

	if (asprintf(&semanage_final_suffix[SEMANAGE_FC_LOCAL_BIN], "%s.bin",

		     semanage_final_suffix[SEMANAGE_FC_LOCAL]) < 0) {

		ERR(sh, "Unable to allocate space for local file context path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_NC] =

		strdup(selinux_netfilter_context_path() + offset);

	if (semanage_final_suffix[SEMANAGE_NC] == NULL) {

		ERR(sh, "Unable to allocate space for netfilter context path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_SEUSERS] =

		strdup(selinux_usersconf_path() + offset);

	if (semanage_final_suffix[SEMANAGE_SEUSERS] == NULL) {

		ERR(sh, "Unable to allocate space for userconf path.");

		status = -1;

		goto cleanup;

	}

	ret = snprintf(path,

		       sizeof(path),

		       "%s.%d",

		       selinux_binary_policy_path() + offset,

		       sh->conf->policyvers);

	if (ret < 0 || ret >= (int)sizeof(path)) {

		ERR(sh, "Unable to compose policy binary path.");

		status = -1;

		goto cleanup;

	}

	semanage_final_suffix[SEMANAGE_KERNEL] = strdup(path);

	if (semanage_final_suffix[SEMANAGE_KERNEL] == NULL) {

		ERR(sh, "Unable to allocate space for policy binary path.");

		status = -1;

		goto cleanup;

	}

cleanup:

	if (status != 0) {

		int i;

		for (i = 0; i < SEMANAGE_FINAL_PATH_NUM; i++) {

			free(semanage_final_suffix[i]);

			semanage_final_suffix[i] = NULL;

		}

	}

	return status;

}

/* Initialize final paths. */

static int semanage_init_final_paths(semanage_handle_t *sh)

{

	int status = 0;

	int i, j;

	size_t len;

	for (i = 0; i < SEMANAGE_FINAL_NUM; i++) {

		for (j = 0; j < SEMANAGE_FINAL_PATH_NUM; j++) {

			len = 	  strlen(semanage_final[i])

				+ strlen(semanage_final_suffix[j]);

			semanage_final_paths[i][j] = malloc(len + 1);

			if (semanage_final_paths[i][j] == NULL) {

				ERR(sh, "Unable to allocate space for policy final path.");

				status = -1;

				goto cleanup;

			}

			sprintf(semanage_final_paths[i][j],

				"%s%s",

				semanage_final[i],

				semanage_final_suffix[j]);

		}

	}

cleanup:

	if (status != 0) {

		for (i = 0; i < SEMANAGE_FINAL_NUM; i++) {

			for (j = 0; j < SEMANAGE_FINAL_PATH_NUM; j++) {

				free(semanage_final_paths[i][j]);

				semanage_final_paths[i][j] = NULL;

			}

		}

	}

	return status;

}

/* THIS MUST BE THE FIRST FUNCTION CALLED IN THIS LIBRARY.  If the

 * library has nnot been initialized yet then call the functions that

 * initialize the path variables.  This function does nothing if it

 * was previously called and that call was successful.  Return 0 on

 * success, -1 on error.

 *

 * Note that this function is NOT thread-safe.

 */

int semanage_check_init(semanage_handle_t *sh, const char *prefix)

{

	int rc;

	if (semanage_paths_initialized == 0) {

		char root[PATH_MAX];

		rc = snprintf(root,

			      sizeof(root),

			      "%s%s/%s",

			      semanage_root(),

			      prefix,

			      sh->conf->store_path);

		if (rc < 0 || rc >= (int)sizeof(root))

			return -1;

		rc = semanage_init_paths(root);

		if (rc)

			return rc;

		rc = semanage_init_store_paths(root);

		if (rc)

			return rc;

		rc = semanage_init_final(sh, prefix);

		if (rc)

			return rc;

		rc = semanage_init_final_suffix(sh);

		if (rc)

			return rc;

		rc = semanage_init_final_paths(sh);

		if (rc)

			return rc;

		semanage_paths_initialized = 1;

	}

	return 0;

}

/* Given a definition number, return a file name from the paths array */

const char *semanage_fname(enum semanage_sandbox_defs file_enum)

{

	return semanage_sandbox_paths[file_enum];

}

/* Given a store location (active/previous/tmp) and a definition

 * number, return a fully-qualified path to that file or directory.

 * The caller must not alter the string returned (and hence why this

 * function return type is const).

 *

 * This function shall never return a NULL, assuming that

 * semanage_check_init() was previously called.

 */

const char *semanage_path(enum semanage_store_defs store,

			  enum semanage_sandbox_defs path_name)

{

	assert(semanage_paths[store][path_name]);

	return semanage_paths[store][path_name];

}

/* Given a store location (tmp or selinux) and a definition

 * number, return a fully-qualified path to that file or directory.

 * The caller must not alter the string returned (and hence why this

 * function return type is const).

 *

 * This function shall never return a NULL, assuming that

 * semanage_check_init() was previously called.

 */

const char *semanage_final_path(enum semanage_final_defs store,

				enum semanage_final_path_defs path_name)

{

	assert(semanage_final_paths[store][path_name]);

	return semanage_final_paths[store][path_name];

}

/* Return a fully-qualified path + filename to the semanage

 * configuration file. If semanage.conf file in the semanage

 * root is cannot be read, use the default semanage.conf as a

 * fallback.

 *

 * The caller is responsible for freeing the returned string.

 */

char *semanage_conf_path(void)

{

	char *semanage_conf = NULL;

	int len;

	struct stat sb;

	len = strlen(semanage_root()) + strlen(selinux_path()) + strlen(SEMANAGE_CONF_FILE);

	semanage_conf = calloc(len + 1, sizeof(char));

	if (!semanage_conf)

		return NULL;

	snprintf(semanage_conf, len + 1, "%s%s%s", semanage_root(), selinux_path(),

		 SEMANAGE_CONF_FILE);

	if (stat(semanage_conf, &sb) != 0 && errno == ENOENT) {

		snprintf(semanage_conf, len + 1, "%s%s", selinux_path(), SEMANAGE_CONF_FILE);

	}

	return semanage_conf;

}

/**************** functions that create module store ***************/

/* Check that the semanage store exists.  If 'create' is non-zero then

 * create the directories.  Returns 0 if module store exists (either

 * already or just created), -1 if does not exist or could not be

 * read, or -2 if it could not create the store. */

int semanage_create_store(semanage_handle_t * sh, int create)

{

	struct stat sb;

	const char *path = semanage_files[SEMANAGE_ROOT];

	int fd;

	mode_t mask;

	if (stat(path, &sb) == -1) {

		if (errno == ENOENT && create) {

			mask = umask(0077);

			if (mkdir(path, S_IRWXU) == -1) {

				umask(mask);

				ERR(sh, "Could not create module store at %s.",

				    path);

				return -2;

			}

			umask(mask);

		} else {

			if (create)

				ERR(sh,

				    "Could not read from module store at %s.",

				    path);

			return -1;

		}

	} else {

		if (!S_ISDIR(sb.st_mode)) {

			ERR(sh,

			    "Module store at %s is not a directory.",

			    path);

			return -1;

		}

	}

	path = semanage_path(SEMANAGE_ACTIVE, SEMANAGE_TOPLEVEL);

	if (stat(path, &sb) == -1) {

		if (errno == ENOENT && create) {

			mask = umask(0077);

			if (mkdir(path, S_IRWXU) == -1) {

				umask(mask);

				ERR(sh,

				    "Could not create module store, active subdirectory at %s.",

				    path);

				return -2;

			}

			umask(mask);

		} else {

			ERR(sh,

			    "Could not read from module store, active subdirectory at %s.",

			    path);

			return -1;

		}

	} else {

		if (!S_ISDIR(sb.st_mode)) {

			ERR(sh,

			    "Module store active subdirectory at %s is not a directory.",

			    path);

			return -1;

		}

	}

	path = semanage_path(SEMANAGE_ACTIVE, SEMANAGE_MODULES);

	if (stat(path, &sb) == -1) {

		if (errno == ENOENT && create) {

			mask = umask(0077);

			if (mkdir(path, S_IRWXU) == -1) {

				umask(mask);

				ERR(sh,

				    "Could not create module store, active modules subdirectory at %s.",

				    path);

				return -2;

			}

			umask(mask);

		} else {

			ERR(sh,

			    "Could not read from module store, active modules subdirectory at %s.",

			    path);

			return -1;

		}

	} else {

		if (!S_ISDIR(sb.st_mode)) {

			ERR(sh,

			    "Module store active modules subdirectory at %s is not a directory.",

			    path);

			return -1;

		}

	}

	path = semanage_files[SEMANAGE_READ_LOCK];

	if (stat(path, &sb) == -1) {

		if (errno == ENOENT && create) {

			mask = umask(0077);

			if ((fd = creat(path, S_IRUSR | S_IWUSR)) == -1) {

				umask(mask);

				ERR(sh, "Could not create lock file at %s.",

				    path);

				return -2;

			}

			umask(mask);

			close(fd);

		} else {

			ERR(sh, "Could not read lock file at %s.", path);

			return -1;

		}

	} else {

		if (!S_ISREG(sb.st_mode)) {

			ERR(sh, "Object at %s is not a lock file.", path);

			return -1;

		}

	}

	return 0;

}

/* returns <0 if the active store cannot be read or doesn't exist

 * 0 if the store exists but the lock file cannot be accessed 

 * SEMANAGE_CAN_READ if the store can be read and the lock file used

 * SEMANAGE_CAN_WRITE if the modules directory and binary policy dir can be written to

 */

int semanage_store_access_check(void)

{

	const char *path;

	int rc = -1;

	/* read access on active store */

	path = semanage_path(SEMANAGE_ACTIVE, SEMANAGE_TOPLEVEL);

	if (access(path, R_OK | X_OK) != 0)

		goto out;

	/* we can read the active store meaning it is managed

	 * so now we return 0 to indicate no error */

	rc = 0;

	/* read access on lock file required for locking

	 * write access necessary if the lock file does not exist

	 */

	path = semanage_files[SEMANAGE_READ_LOCK];

	if (access(path, R_OK) != 0) {

		if (access(path, F_OK) == 0) {

			goto out;

		}

		path = semanage_files[SEMANAGE_ROOT];

		if (access(path, R_OK | W_OK | X_OK) != 0) {

			goto out;

		}

	}

	/* everything needed for reading has been checked */

	rc = SEMANAGE_CAN_READ;

	/* check the modules directory */

	path = semanage_path(SEMANAGE_ACTIVE, SEMANAGE_MODULES);

	if (access(path, R_OK | W_OK | X_OK) != 0)

		goto out;

	rc = SEMANAGE_CAN_WRITE;

      out:

	return rc;

}

/********************* other I/O functions *********************/

/* Callback used by scandir() to select files. */

static int semanage_filename_select(const struct dirent *d)

{

	if (d->d_name[0] == '.'

	    && (d->d_name[1] == '\0'

		|| (d->d_name[1] == '.' && d->d_name[2] == '\0')))

		return 0;

	return 1;

}

/* Copies a file from src to dst.  If dst already exists then

 * overwrite it.  Returns 0 on success, -1 on error. */

int semanage_copy_file(const char *src, const char *dst, mode_t mode,

		bool syncrequired)

{

	int in, out, retval = 0, amount_read, n, errsv = errno;

	char tmp[PATH_MAX];

	char buf[4192];

	mode_t mask;

	n = snprintf(tmp, PATH_MAX, "%s.tmp", dst);

	if (n < 0 || n >= PATH_MAX)

		return -1;

	if ((in = open(src, O_RDONLY)) == -1) {

		return -1;

	}

	if (!mode)

		mode = S_IRUSR | S_IWUSR;

	mask = umask(0);

	if ((out = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, mode)) == -1) {

		umask(mask);

		errsv = errno;

		close(in);

		retval = -1;

		goto out;

	}

	umask(mask);

	while (retval == 0 && (amount_read = read(in, buf, sizeof(buf))) > 0) {

		if (write(out, buf, amount_read) != amount_read) {

			if (errno)

				errsv = errno;

			else

				errsv = EIO;

			retval = -1;

		}

	}

	if (amount_read < 0) {

		errsv = errno;

		retval = -1;

	}

	close(in);

	if (syncrequired && fsync(out) < 0) {

		errsv = errno;

		retval = -1;

	}

	if (close(out) < 0) {

		errsv = errno;

		retval = -1;

	}

	if (!retval && rename(tmp, dst) == -1)

		return -1;

out:

	errno = errsv;

	return retval;

}

static int semanage_copy_dir_flags(const char *src, const char *dst, int flag);

/* Copies all of the files from src to dst, recursing into

 * subdirectories.  Returns 0 on success, -1 on error. */

static int semanage_copy_dir(const char *src, const char *dst)

{

	return semanage_copy_dir_flags(src, dst, 1);

}

/* Copies all of the dirs from src to dst, recursing into

 * subdirectories. If flag == 1, then copy regular files as

 * well. Returns 0 on success, -1 on error. */

static int semanage_copy_dir_flags(const char *src, const char *dst, int flag)

{

	int i, len = 0, retval = -1;

	struct stat sb;

	struct dirent **names = NULL;

	char path[PATH_MAX], path2[PATH_MAX];

	mode_t mask;

	if ((len = scandir(src, &names, semanage_filename_select, NULL)) == -1) {

		fprintf(stderr, "Could not read the contents of %s: %s\n", src, strerror(errno));

		return -1;

	}

	if (stat(dst, &sb) != 0) {

		mask = umask(0077);

		if (mkdir(dst, S_IRWXU) != 0) {

			umask(mask);

			fprintf(stderr, "Could not create %s: %s\n", dst, strerror(errno));

			goto cleanup;

		}

		umask(mask);

	}

	for (i = 0; i < len; i++) {

		snprintf(path, sizeof(path), "%s/%s", src, names[i]->d_name);

		/* stat() to see if this entry is a file or not since

		 * d_type isn't set properly on XFS */

		if (stat(path, &sb)) {

			goto cleanup;

		}

		snprintf(path2, sizeof(path2), "%s/%s", dst, names[i]->d_name);

		if (S_ISDIR(sb.st_mode)) {

			mask = umask(0077);

			if (mkdir(path2, 0700) == -1 ||

			    semanage_copy_dir_flags(path, path2, flag) == -1) {

				umask(mask);

				goto cleanup;

			}

			umask(mask);

		} else if (S_ISREG(sb.st_mode) && flag == 1) {

			mask = umask(0077);

			if (semanage_copy_file(path, path2, sb.st_mode,

						false) < 0) {

				umask(mask);

				goto cleanup;

			}

			umask(mask);

		}

	}

	retval = 0;

      cleanup:

	for (i = 0; names != NULL && i < len; i++) {

		free(names[i]);

	}

	free(names);

	return retval;

}

/* Recursively removes the contents of a directory along with the

 * directory itself.  Returns 0 on success, non-zero on error. */

int semanage_remove_directory(const char *path)

{

	struct dirent **namelist = NULL;

	int num_entries, i;

	if ((num_entries = scandir(path, &namelist, semanage_filename_select,

				   NULL)) == -1) {

		return -1;

	}

	for (i = 0; i < num_entries; i++) {

		char s[PATH_MAX];

		struct stat buf;

		snprintf(s, sizeof(s), "%s/%s", path, namelist[i]->d_name);

		if (stat(s, &buf) == -1) {

			return -2;

		}

		if (S_ISDIR(buf.st_mode)) {

			int retval;

			if ((retval = semanage_remove_directory(s)) != 0) {

				return retval;

			}

		} else {

			if (remove(s) == -1) {

				return -3;

			}

		}

		free(namelist[i]);

	}

	free(namelist);

	if (rmdir(path) == -1) {

		return -4;

	}

	return 0;

}

int semanage_mkpath(semanage_handle_t *sh, const char *path)

{

	char fn[PATH_MAX];

	char *c;

	int rc = 0;