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

/* Object: semanage_user_t (SELinux User/Class)

 * Object: semanage_user_key_t (SELinux User/Class Key)

 * Implements: record_t (Database Record)

 * Implements: record_key_t (Database Record Key)

 */

#include <sepol/user_record.h>

typedef sepol_user_key_t semanage_user_key_t;

#define _SEMANAGE_USER_KEY_DEFINED_

struct semanage_user;

typedef struct semanage_user record_t;

typedef semanage_user_key_t record_key_t;

#define DBASE_RECORD_DEFINED

#include <stdlib.h>

#include <string.h>

#include "user_internal.h"

#include "handle.h"

#include "database.h"

#include "debug.h"

struct semanage_user {

	char *name;

	semanage_user_base_t *base;

	semanage_user_extra_t *extra;

};

/* Key */

int semanage_user_key_create(semanage_handle_t * handle,

			     const char *name, semanage_user_key_t ** key)

{

	return sepol_user_key_create(handle->sepolh, name, key);

}

hidden_def(semanage_user_key_create)

int semanage_user_key_extract(semanage_handle_t * handle,

			      const semanage_user_t * user,

			      semanage_user_key_t ** key)

{

	return semanage_user_base_key_extract(handle, user->base, key);

}

hidden_def(semanage_user_key_extract)

void semanage_user_key_free(semanage_user_key_t * key)

{

	sepol_user_key_free(key);

}

hidden_def(semanage_user_key_free)

hidden void semanage_user_key_unpack(const semanage_user_key_t * key,

				     const char **name)

{

	sepol_user_key_unpack(key, name);

}

int semanage_user_compare(const semanage_user_t * user,

			  const semanage_user_key_t * key)

{

	const char *name;

	sepol_user_key_unpack(key, &name);

	return strcmp(user->name, name);

}

hidden_def(semanage_user_compare)

int semanage_user_compare2(const semanage_user_t * user,

			   const semanage_user_t * user2)

{

	return strcmp(user->name, user2->name);

}

hidden_def(semanage_user_compare2)

static int semanage_user_compare2_qsort(const semanage_user_t ** user,

					const semanage_user_t ** user2)

{

	return strcmp((*user)->name, (*user2)->name);

}

/* Name */

const char *semanage_user_get_name(const semanage_user_t * user)

{

	return user->name;

}

hidden_def(semanage_user_get_name)

int semanage_user_set_name(semanage_handle_t * handle,

			   semanage_user_t * user, const char *name)

{

	char *tmp_name = strdup(name);

	if (!tmp_name)

		goto omem;

	if (semanage_user_base_set_name(handle, user->base, name) < 0)

		goto err;

	if (semanage_user_extra_set_name(handle, user->extra, name) < 0)

		goto err;

	free(user->name);

	user->name = tmp_name;

	return STATUS_SUCCESS;

      omem:

	ERR(handle, "out of memory");

      err:

	ERR(handle, "could not set user name to %s", name);

	free(tmp_name);

	return STATUS_ERR;

}

hidden_def(semanage_user_set_name)

/* Labeling prefix */

const char *semanage_user_get_prefix(const semanage_user_t * user)

{

	return semanage_user_extra_get_prefix(user->extra);

}

int semanage_user_set_prefix(semanage_handle_t * handle,

			     semanage_user_t * user, const char *name)

{

	return semanage_user_extra_set_prefix(handle, user->extra, name);

}

/* MLS */

const char *semanage_user_get_mlslevel(const semanage_user_t * user)

{

	return semanage_user_base_get_mlslevel(user->base);

}

hidden_def(semanage_user_get_mlslevel)

int semanage_user_set_mlslevel(semanage_handle_t * handle,

			       semanage_user_t * user, const char *mls_level)

{

	return semanage_user_base_set_mlslevel(handle, user->base, mls_level);

}

hidden_def(semanage_user_set_mlslevel)

const char *semanage_user_get_mlsrange(const semanage_user_t * user)

{

	return semanage_user_base_get_mlsrange(user->base);

}

hidden_def(semanage_user_get_mlsrange)

int semanage_user_set_mlsrange(semanage_handle_t * handle,

			       semanage_user_t * user, const char *mls_range)

{

	return semanage_user_base_set_mlsrange(handle, user->base, mls_range);

}

hidden_def(semanage_user_set_mlsrange)

/* Role management */

int semanage_user_get_num_roles(const semanage_user_t * user)

{

	return semanage_user_base_get_num_roles(user->base);

}

int semanage_user_add_role(semanage_handle_t * handle,

			   semanage_user_t * user, const char *role)

{

	return semanage_user_base_add_role(handle, user->base, role);

}

hidden_def(semanage_user_add_role)

void semanage_user_del_role(semanage_user_t * user, const char *role)

{

	semanage_user_base_del_role(user->base, role);

}

int semanage_user_has_role(const semanage_user_t * user, const char *role)

{

	return semanage_user_base_has_role(user->base, role);

}

int semanage_user_get_roles(semanage_handle_t * handle,

			    const semanage_user_t * user,

			    const char ***roles_arr, unsigned int *num_roles)

{

	return semanage_user_base_get_roles(handle, user->base, roles_arr,

					    num_roles);

}

hidden_def(semanage_user_get_roles)

int semanage_user_set_roles(semanage_handle_t * handle,

			    semanage_user_t * user,

			    const char **roles_arr, unsigned int num_roles)

{

	return semanage_user_base_set_roles(handle, user->base, roles_arr,

					    num_roles);

}

/* Create/Clone/Destroy */

int semanage_user_create(semanage_handle_t * handle,

			 semanage_user_t ** user_ptr)

{

	semanage_user_t *tmp_user = calloc(1, sizeof(semanage_user_t));

	if (!tmp_user)

		goto omem;

	if (semanage_user_base_create(handle, &tmp_user->base) < 0)

		goto err;

	if (semanage_user_extra_create(handle, &tmp_user->extra) < 0)

		goto err;

	/* Initialize the prefix for migration purposes */

	if (semanage_user_extra_set_prefix(handle, tmp_user->extra, "user") < 0)

		goto err;

	*user_ptr = tmp_user;

	return STATUS_SUCCESS;

      omem:

	ERR(handle, "out of memory");

      err:

	ERR(handle, "could not create user record");

	semanage_user_free(tmp_user);

	return STATUS_ERR;

}

hidden_def(semanage_user_create)

int semanage_user_clone(semanage_handle_t * handle,

			const semanage_user_t * user,

			semanage_user_t ** user_ptr)

{

	semanage_user_t *tmp_user = calloc(1, sizeof(semanage_user_t));

	if (!tmp_user)

		goto omem;

	/* Clone base and extra records */

	if (semanage_user_base_clone(handle, user->base, &tmp_user->base) < 0)

		goto err;

	if (semanage_user_extra_clone(handle, user->extra, &tmp_user->extra) <

	    0)

		goto err;

	/* Set the shared name */

	if (semanage_user_set_name(handle, tmp_user, user->name) < 0)

		goto err;

	*user_ptr = tmp_user;

	return STATUS_SUCCESS;

      omem:

	ERR(handle, "out of memory");

      err:

	ERR(handle, "could not clone user record");

	semanage_user_free(tmp_user);

	return STATUS_ERR;

}

hidden_def(semanage_user_clone)

void semanage_user_free(semanage_user_t * user)

{

	if (!user)

		return;

	semanage_user_base_free(user->base);

	semanage_user_extra_free(user->extra);

	free(user->name);

	free(user);

}

hidden_def(semanage_user_free)

/* Join properties */

hidden int semanage_user_join(semanage_handle_t * handle,

			      const semanage_user_base_t * record1,

			      const semanage_user_extra_t * record2,

			      semanage_user_t ** result)

{

	const char *name;

	semanage_user_t *tmp_user = calloc(1, sizeof(semanage_user_t));

	if (!tmp_user)

		goto omem;

	/* Set the shared name from one of the records 

	 * (at least one is available) */

	if (record1 == NULL)

		name = semanage_user_extra_get_name(record2);

	else

		name = semanage_user_base_get_name(record1);

	/* Join base record if it exists, create a blank one otherwise */

	if (record1) {

		if (semanage_user_base_clone(handle, record1, &tmp_user->base) <

		    0)

			goto err;

	} else {

		if (semanage_user_base_create(handle, &tmp_user->base) < 0)

			goto err;

		if (semanage_user_base_set_name(handle, tmp_user->base, name) <

		    0)

			goto err;

	}

	/* Join extra record if it exists, create a blank one otherwise */

	if (record2) {

		if (semanage_user_extra_clone(handle, record2, &tmp_user->extra)

		    < 0)

			goto err;

	} else {

		if (semanage_user_extra_create(handle, &tmp_user->extra) < 0)

			goto err;

		if (semanage_user_extra_set_name(handle, tmp_user->extra, name)

		    < 0)

			goto err;

		if (semanage_user_extra_set_prefix

		    (handle, tmp_user->extra, "user") < 0)

			goto err;

	}

	if (semanage_user_set_name(handle, tmp_user, name) < 0)

		goto err;

	*result = tmp_user;

	return STATUS_SUCCESS;

      omem:

	ERR(handle, "out of memory");

      err:

	ERR(handle, "could not join data records for user %s",

	    semanage_user_base_get_name(record1));

	semanage_user_free(tmp_user);

	return STATUS_ERR;

}

hidden int semanage_user_split(semanage_handle_t * handle,

			       const semanage_user_t * record,

			       semanage_user_base_t ** split1,

			       semanage_user_extra_t ** split2)

{

	semanage_user_base_t *tmp_base_user = NULL;

	semanage_user_extra_t *tmp_extra_user = NULL;

	if (semanage_user_base_clone(handle, record->base, &tmp_base_user) < 0)

		goto err;

	if (semanage_user_extra_clone(handle, record->extra, &tmp_extra_user) <

	    0)

		goto err;

	*split1 = tmp_base_user;

	*split2 = tmp_extra_user;

	return STATUS_SUCCESS;

      err:

	ERR(handle, "could not split data records for user %s",

	    semanage_user_get_name(record));

	semanage_user_base_free(tmp_base_user);

	semanage_user_extra_free(tmp_extra_user);

	return STATUS_ERR;

}

/* Record base functions */

record_table_t SEMANAGE_USER_RTABLE = {

	.create = semanage_user_create,

	.key_extract = semanage_user_key_extract,

	.key_free = semanage_user_key_free,

	.clone = semanage_user_clone,

	.compare = semanage_user_compare,

	.compare2 = semanage_user_compare2,

	.compare2_qsort = semanage_user_compare2_qsort,

	.free = semanage_user_free,

};