/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma weak _ucred_free = ucred_free

#pragma weak _ucred_get = ucred_get

#pragma weak _ucred_getegid = ucred_getegid

#pragma weak _ucred_geteuid = ucred_geteuid

#pragma weak _ucred_getgroups = ucred_getgroups

#pragma weak _ucred_getpflags = ucred_getpflags

#pragma weak _ucred_getpid = ucred_getpid

#pragma weak _ucred_getzoneid = ucred_getzoneid

#pragma weak _ucred_getprojid = ucred_getprojid

#pragma weak _ucred_getprivset = ucred_getprivset

#pragma weak _ucred_getrgid = ucred_getrgid

#pragma weak _ucred_getruid = ucred_getruid

#pragma weak _ucred_getsgid = ucred_getsgid

#pragma weak _ucred_getsuid = ucred_getsuid

#pragma weak _ucred_getauid = ucred_getauid

#pragma weak _ucred_getasid = ucred_getasid

#pragma weak _ucred_getatid = ucred_getatid

#pragma weak _ucred_getlabel = ucred_getlabel

#pragma weak _ucred_getamask = ucred_getamask

#pragma weak _ucred_size = ucred_size

#include "lint.h"

#define	_STRUCTURED_PROC	1

#include "priv_private.h"

#include <errno.h>

#include <priv.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <ucred.h>

#include <limits.h>

#include <fcntl.h>

#include <door.h>

#include <alloca.h>

#include <sys/ucred.h>

#include <sys/procfs.h>

#include <sys/sysmacros.h>

#include <sys/zone.h>

#include <tsol/label.h>

ucred_t *

_ucred_alloc(void)

{

	ucred_t *r;

	size_t sz = ucred_size();

	r = malloc(sz);

	if (r != NULL)

		r->uc_size = (uint32_t)sz;

	return (r);

}

void

ucred_free(ucred_t *uc)

{

	free(uc);

}

ucred_t *

ucred_get(pid_t pid)

{

	ucred_t *uc;

	uc = _ucred_alloc();

	if (uc == NULL)

		return (NULL);

	if (syscall(SYS_ucredsys, UCREDSYS_UCREDGET, pid, uc) != 0) {

		ucred_free(uc);

		return (NULL);

	}

	return (uc);

}

uid_t

ucred_geteuid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((uid_t)-1);

	}

	return (cr->pr_euid);

}

uid_t

ucred_getruid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((uid_t)-1);

	}

	return (cr->pr_ruid);

}

uid_t

ucred_getsuid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((uid_t)-1);

	}

	return (cr->pr_suid);

}

gid_t

ucred_getegid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((gid_t)-1);

	}

	return (cr->pr_egid);

}

gid_t

ucred_getrgid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((gid_t)-1);

	}

	return (cr->pr_rgid);

}

gid_t

ucred_getsgid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return ((gid_t)-1);

	}

	return (cr->pr_sgid);

}

int

ucred_getgroups(const ucred_t *uc, const gid_t **grps)

{

	/* LINTED: alignment */

	const prcred_t *cr = UCCRED(uc);

	if (cr == NULL) {

		errno = EINVAL;

		return (-1);

	}

	if (cr->pr_ngroups > 0)

		*grps = &cr->pr_groups[0];

	else

		*grps = NULL;

	return (cr->pr_ngroups);

}

const priv_set_t *

ucred_getprivset(const ucred_t *uc, priv_ptype_t set)

{

	/* LINTED: alignment */

	const prpriv_t *pr = UCPRIV(uc);

	int pset = priv_getsetbyname(set);

	priv_data_t *d;

	if (pr == NULL || pset == -1) {

		errno = EINVAL;

		return (NULL);

	}

	LOADPRIVDATA(d);

	return ((const priv_set_t *)

	    &pr->pr_sets[d->pd_pinfo->priv_setsize * pset]);

}

pid_t

ucred_getpid(const ucred_t *uc)

{

	if (uc->uc_pid == -1)

		errno = EINVAL;

	return (uc->uc_pid);

}

projid_t

ucred_getprojid(const ucred_t *uc)

{

	if (uc->uc_projid == -1)

		errno = EINVAL;

	return (uc->uc_projid);

}

zoneid_t

ucred_getzoneid(const ucred_t *uc)

{

	if (uc->uc_zoneid < MIN_ZONEID || uc->uc_zoneid > MAX_ZONEID) {

		errno = EINVAL;

		return (-1);

	}

	return (uc->uc_zoneid);

}

bslabel_t *

ucred_getlabel(const ucred_t *uc)

{

	/* LINTED: alignment */

	bslabel_t *slabel = UCLABEL(uc);

	if (!is_system_labeled() || slabel == NULL) {

		errno = EINVAL;

		return (NULL);

	}

	return (slabel);

}

/*

 * For now, assume single bit flags.

 */

uint_t

ucred_getpflags(const ucred_t *uc, uint_t flag)

{

	/* LINTED: alignment */

	prpriv_t *pr = UCPRIV(uc);

	char *x, *end;

	if (pr == NULL) {

		errno = EINVAL;

		return ((uint_t)-1);

	}

	end = (char *)pr + PRIV_PRPRIV_SIZE(pr);

	x = end - pr->pr_infosize;

	while (x < end) {

		/* LINTED: alignment */

		priv_info_t *pi = (priv_info_t *)x;

		priv_info_uint_t *pii;

		switch (pi->priv_info_type) {

		case PRIV_INFO_FLAGS:

			/* LINTED: alignment */

			pii = (priv_info_uint_t *)x;

			return ((pii->val & flag) ? 1 : 0);

		}

		/* Forward progress */

		if (pi->priv_info_size < sizeof (priv_info_t))

			break;

		x += pi->priv_info_size;

	}

	errno = EINVAL;

	return ((uint_t)-1);

}

au_id_t

ucred_getauid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const auditinfo64_addr_t *ainfo = UCAUD(uc);

	if (ainfo == NULL)

		return (AU_NOAUDITID);

	return (ainfo->ai_auid);

}

au_asid_t

ucred_getasid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const auditinfo64_addr_t *ainfo = UCAUD(uc);

	if (ainfo == NULL)

		return ((au_asid_t)-1);

	return (ainfo->ai_asid);

}

const au_tid64_addr_t *

ucred_getatid(const ucred_t *uc)

{

	/* LINTED: alignment */

	const auditinfo64_addr_t *ainfo = UCAUD(uc);

	if (ainfo == NULL) {

		errno = EINVAL;

		return (NULL);

	}

	return (&ainfo->ai_termid);

}

const au_mask_t *

ucred_getamask(const ucred_t *uc)

{

	/* LINTED: alignment */

	const auditinfo64_addr_t *ainfo = UCAUD(uc);

	if (ainfo == NULL) {

		errno = EINVAL;

		return (NULL);

	}

	return (&ainfo->ai_mask);

}

size_t

ucred_size(void)

{

	priv_data_t *d;

	LOADPRIVDATA(d);

	return (d->pd_ucredsize);

}