/*

 * 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

 */

/*

 */

#include <sys/systm.h>

#include <sys/errno.h>

#include <sys/policy.h>

#include <c2/audit.h>

#include <c2/audit_kernel.h>

#include <c2/audit_record.h>

#define	CLEAR_VAL -1

extern kmutex_t pidlock;

uint32_t audit_policy; /* global audit policies in force */

/*ARGSUSED1*/

int

auditsys(struct auditcalls *uap, rval_t *rvp)

{

	int err;

	int result = 0;

	if (audit_active == C2AUDIT_DISABLED)

		return (ENOTSUP);

	switch (uap->code) {

	case BSM_GETAUID:

		result = getauid((caddr_t)uap->a1);

		break;

	case BSM_SETAUID:

		result = setauid((caddr_t)uap->a1);

		break;

	case BSM_GETAUDIT:

		result = getaudit((caddr_t)uap->a1);

		break;

	case BSM_GETAUDIT_ADDR:

		result = getaudit_addr((caddr_t)uap->a1, (int)uap->a2);

		break;

	case BSM_SETAUDIT:

		result = setaudit((caddr_t)uap->a1);

		break;

	case BSM_SETAUDIT_ADDR:

		result = setaudit_addr((caddr_t)uap->a1, (int)uap->a2);

		break;

	case BSM_AUDITCTL:

		result = auditctl((int)uap->a1, (caddr_t)uap->a2, (int)uap->a3);

		break;

	case BSM_AUDIT:

		if (audit_active == C2AUDIT_UNLOADED)

			return (0);

		result = audit((caddr_t)uap->a1, (int)uap->a2);

		break;

	case BSM_AUDITDOOR:

		if (audit_active == C2AUDIT_LOADED) {

			result = auditdoor((int)uap->a1);

			break;

		}

	default:

		if (audit_active == C2AUDIT_LOADED) {

			result = EINVAL;

			break;

		}

		/* Return a different error when not privileged */

		err = secpolicy_audit_config(CRED());

		if (err == 0)

			return (EINVAL);

		else

			return (err);

	}

	rvp->r_vals = result;

	return (result);

}

/*

 * Return the audit user ID for the current process.  Currently only

 * the privileged processes may see the audit id.  That may change.

 * If copyout is unsucessful return EFAULT.

 */

int

getauid(caddr_t auid_p)

{

	const auditinfo_addr_t	*ainfo;

		return (EPERM);

	ainfo = crgetauinfo(CRED());

	if (ainfo == NULL)

		return (EINVAL);

	if (copyout(&ainfo->ai_auid, auid_p, sizeof (au_id_t)))

		return (EFAULT);

	return (0);

}

/*

 * Set the audit userid, for a process.  This can only be changed by

 * privileged processes.  The audit userid is inherited across forks & execs.

 * Passed in is a pointer to the au_id_t; if copyin unsuccessful return EFAULT.

 */

int

setauid(caddr_t auid_p)

{

	proc_t *p;

	au_id_t	auid;

	cred_t *newcred;

	auditinfo_addr_t *auinfo;

	if (secpolicy_audit_config(CRED()) != 0)

		return (EPERM);

	if (copyin(auid_p, &auid, sizeof (au_id_t))) {

		return (EFAULT);

	}

	newcred = cralloc();

	if ((auinfo = crgetauinfo_modifiable(newcred)) == NULL) {

		crfree(newcred);

		return (EINVAL);

	}

	/* grab p_crlock and switch to new cred */

	p = curproc;

	mutex_enter(&p->p_crlock);

	crcopy_to(p->p_cred, newcred);

	p->p_cred = newcred;

	auinfo->ai_auid = auid;			/* update the auid */

	/* unlock and broadcast the cred changes */

	mutex_exit(&p->p_crlock);

	crset(p, newcred);

	return (0);

}

/*

 * Get the audit state information from the current process.

 * Return EFAULT if copyout fails.

 */

int

getaudit(caddr_t info_p)

{

	STRUCT_DECL(auditinfo, info);

	const auditinfo_addr_t	*ainfo;

	model_t	model;

		return (EPERM);

	model = get_udatamodel();

	STRUCT_INIT(info, model);

	ainfo = crgetauinfo(CRED());

	if (ainfo == NULL)

		return (EINVAL);

	/* trying to read a process with an IPv6 address? */

	if (ainfo->ai_termid.at_type == AU_IPv6)

		return (EOVERFLOW);

	STRUCT_FSET(info, ai_auid, ainfo->ai_auid);

	STRUCT_FSET(info, ai_mask, ainfo->ai_mask);

#ifdef _LP64

	if (model == DATAMODEL_ILP32) {

		dev32_t dev;

		/* convert internal 64 bit form to 32 bit version */

		if (cmpldev(&dev, ainfo->ai_termid.at_port) == 0) {

			return (EOVERFLOW);

		}

		STRUCT_FSET(info, ai_termid.port, dev);

	} else

		STRUCT_FSET(info, ai_termid.port, ainfo->ai_termid.at_port);

#else

	STRUCT_FSET(info, ai_termid.port, ainfo->ai_termid.at_port);

#endif

	STRUCT_FSET(info, ai_termid.machine, ainfo->ai_termid.at_addr[0]);

	STRUCT_FSET(info, ai_asid, ainfo->ai_asid);

	if (copyout(STRUCT_BUF(info), info_p, STRUCT_SIZE(info)))

		return (EFAULT);

	return (0);

}

/*

 * Get the audit state information from the current process.

 * Return EFAULT if copyout fails.

 */

int

getaudit_addr(caddr_t info_p, int len)

{

	STRUCT_DECL(auditinfo_addr, info);

	const auditinfo_addr_t	*ainfo;

	model_t	model;

		return (EPERM);

	model = get_udatamodel();

	STRUCT_INIT(info, model);

	if (len < STRUCT_SIZE(info))

		return (EOVERFLOW);

	ainfo = crgetauinfo(CRED());

	if (ainfo == NULL)

		return (EINVAL);

	STRUCT_FSET(info, ai_auid, ainfo->ai_auid);

	STRUCT_FSET(info, ai_mask, ainfo->ai_mask);

#ifdef _LP64

	if (model == DATAMODEL_ILP32) {

		dev32_t dev;

		/* convert internal 64 bit form to 32 bit version */

		if (cmpldev(&dev, ainfo->ai_termid.at_port) == 0) {

			return (EOVERFLOW);

		}

		STRUCT_FSET(info, ai_termid.at_port, dev);

	} else

		STRUCT_FSET(info, ai_termid.at_port, ainfo->ai_termid.at_port);

#else

	STRUCT_FSET(info, ai_termid.at_port, ainfo->ai_termid.at_port);

#endif

	STRUCT_FSET(info, ai_termid.at_type, ainfo->ai_termid.at_type);

	STRUCT_FSET(info, ai_termid.at_addr[0], ainfo->ai_termid.at_addr[0]);

	STRUCT_FSET(info, ai_termid.at_addr[1], ainfo->ai_termid.at_addr[1]);

	STRUCT_FSET(info, ai_termid.at_addr[2], ainfo->ai_termid.at_addr[2]);

	STRUCT_FSET(info, ai_termid.at_addr[3], ainfo->ai_termid.at_addr[3]);

	STRUCT_FSET(info, ai_asid, ainfo->ai_asid);

	if (copyout(STRUCT_BUF(info), info_p, STRUCT_SIZE(info)))

		return (EFAULT);

	return (0);

}

/*

 * Set the audit state information for the current process.

 * Return EFAULT if copyout fails.

 */

int

setaudit(caddr_t info_p)

{

	STRUCT_DECL(auditinfo, info);

	proc_t *p;

	cred_t	*newcred;

	model_t	model;

	auditinfo_addr_t *ainfo;

	if (secpolicy_audit_config(CRED()) != 0)

		return (EPERM);

	model = get_udatamodel();

	STRUCT_INIT(info, model);

	if (copyin(info_p, STRUCT_BUF(info), STRUCT_SIZE(info)))

		return (EFAULT);

	newcred = cralloc();

	if ((ainfo = crgetauinfo_modifiable(newcred)) == NULL) {

		crfree(newcred);

		return (EINVAL);

	}

	/* grab p_crlock and switch to new cred */

	p = curproc;

	mutex_enter(&p->p_crlock);

	crcopy_to(p->p_cred, newcred);

	p->p_cred = newcred;

	/* Set audit mask, id, termid and session id as specified */

	ainfo->ai_auid = STRUCT_FGET(info, ai_auid);

#ifdef _LP64

	/* only convert to 64 bit if coming from a 32 bit binary */

	if (model == DATAMODEL_ILP32)

		ainfo->ai_termid.at_port =

		    DEVEXPL(STRUCT_FGET(info, ai_termid.port));

	else

		ainfo->ai_termid.at_port = STRUCT_FGET(info, ai_termid.port);

#else

	ainfo->ai_termid.at_port = STRUCT_FGET(info, ai_termid.port);

#endif

	ainfo->ai_termid.at_type = AU_IPv4;

	ainfo->ai_termid.at_addr[0] = STRUCT_FGET(info, ai_termid.machine);

	ainfo->ai_asid = STRUCT_FGET(info, ai_asid);

	ainfo->ai_mask = STRUCT_FGET(info, ai_mask);

	/* unlock and broadcast the cred changes */

	mutex_exit(&p->p_crlock);

	crset(p, newcred);

	return (0);

}

/*

 * Set the audit state information for the current process.

 * Return EFAULT if copyin fails.

 */

int

setaudit_addr(caddr_t info_p, int len)

{

	STRUCT_DECL(auditinfo_addr, info);

	proc_t *p;

	cred_t	*newcred;

	model_t	model;

	int i;

	int type;

	auditinfo_addr_t *ainfo;

	if (secpolicy_audit_config(CRED()) != 0)

		return (EPERM);

	model = get_udatamodel();

	STRUCT_INIT(info, model);

	if (len < STRUCT_SIZE(info))

		return (EOVERFLOW);

	if (copyin(info_p, STRUCT_BUF(info), STRUCT_SIZE(info)))

		return (EFAULT);

	type = STRUCT_FGET(info, ai_termid.at_type);

	if ((type != AU_IPv4) && (type != AU_IPv6))

		return (EINVAL);

	newcred = cralloc();

	if ((ainfo = crgetauinfo_modifiable(newcred)) == NULL) {

		crfree(newcred);

		return (EINVAL);

	}

	/* grab p_crlock and switch to new cred */

	p = curproc;

	mutex_enter(&p->p_crlock);

	crcopy_to(p->p_cred, newcred);

	p->p_cred = newcred;

	/* Set audit mask, id, termid and session id as specified */

	ainfo->ai_auid = STRUCT_FGET(info, ai_auid);

	ainfo->ai_mask = STRUCT_FGET(info, ai_mask);

#ifdef _LP64

	/* only convert to 64 bit if coming from a 32 bit binary */

	if (model == DATAMODEL_ILP32)

		ainfo->ai_termid.at_port =

		    DEVEXPL(STRUCT_FGET(info, ai_termid.at_port));

	else

		ainfo->ai_termid.at_port = STRUCT_FGET(info, ai_termid.at_port);

#else

	ainfo->ai_termid.at_port = STRUCT_FGET(info, ai_termid.at_port);

#endif

	ainfo->ai_termid.at_type = type;

	bzero(&ainfo->ai_termid.at_addr[0], sizeof (ainfo->ai_termid.at_addr));

	for (i = 0; i < (type/sizeof (int)); i++)

		ainfo->ai_termid.at_addr[i] =

		    STRUCT_FGET(info, ai_termid.at_addr[i]);

	if (ainfo->ai_termid.at_type == AU_IPv6 &&

	    IN6_IS_ADDR_V4MAPPED(((in6_addr_t *)ainfo->ai_termid.at_addr))) {

		ainfo->ai_termid.at_type = AU_IPv4;

		ainfo->ai_termid.at_addr[0] = ainfo->ai_termid.at_addr[3];

		ainfo->ai_termid.at_addr[1] = 0;

		ainfo->ai_termid.at_addr[2] = 0;

		ainfo->ai_termid.at_addr[3] = 0;

	}

	ainfo->ai_asid = STRUCT_FGET(info, ai_asid);

	/* unlock and broadcast the cred changes */

	mutex_exit(&p->p_crlock);

	crset(p, newcred);

	return (0);

}

/*

 * Get the global policy flag

 */

static int

getpolicy(caddr_t data)

{

	uint32_t	policy;

	au_kcontext_t	*kctx = GET_KCTX_PZ;

	policy = audit_policy | kctx->auk_policy;

	if (copyout(&policy, data, sizeof (policy)))

		return (EFAULT);

	return (0);

}

/*

 * Set the global and local policy flags

 *

 * The global flags only make sense from the global zone;

 * the local flags depend on the AUDIT_PERZONE policy:

 * if the perzone policy is set, then policy is set separately

 * per zone, else held only in the global zone.

 *

 * The initial value of a local zone's policy flag is determined

 * by the value of the global zone's flags at the time the

 * local zone is created.

 *

 * While auditconfig(1M) allows setting and unsetting policies one bit

 * at a time, the mask passed in from auditconfig() is created by a

 * syscall to getpolicy and then modified based on the auditconfig()

 * cmd line, so the input policy value is used to replace the existing

 * policy.

 */

static int

setpolicy(caddr_t data)

{

	uint32_t	policy;

	au_kcontext_t	*kctx;

	if (copyin(data, &policy, sizeof (policy)))

		return (EFAULT);

	kctx = GET_KCTX_NGZ;

	if (INGLOBALZONE(curproc)) {

		if (policy & ~(AUDIT_GLOBAL | AUDIT_LOCAL))

			return (EINVAL);

		audit_policy = policy & AUDIT_GLOBAL;

	} else {

		if (!(audit_policy & AUDIT_PERZONE))

			return (EINVAL);

		if (policy & ~AUDIT_LOCAL)	/* global bits are a no-no */

			return (EINVAL);

	}

	kctx->auk_policy = policy & AUDIT_LOCAL;

	/*

	 * auk_current_vp is NULL before auditd starts (or during early

	 * auditd starup) or if auditd is halted; in either case,

	 * notification of a policy change is not needed, since auditd

	 * reads policy as it comes up.  The error return from au_doormsg()

	 * is ignored to avoid a race condition -- for example if auditd

	 * segv's, the audit state may be "auditing" but the door may

	 * be closed.  Returning an error if the door is open makes it

	 * impossible for Greenline to restart auditd.

	 */

	if (kctx->auk_current_vp != NULL)

		(void) au_doormsg(kctx, AU_DBUF_POLICY, &policy);

	/*

	 * Wake up anyone who might have blocked on full audit

	 * partitions. audit daemons need to set AUDIT_FULL when no

	 * space so we can tell if we should start dropping records.

	 */

	mutex_enter(&(kctx->auk_queue.lock));

	if ((policy & (AUDIT_CNT | AUDIT_SCNT) &&

	    (kctx->auk_queue.cnt >= kctx->auk_queue.hiwater)))

		cv_broadcast(&(kctx->auk_queue.write_cv));

	mutex_exit(&(kctx->auk_queue.lock));

	return (0);

}

static int

getkmask(caddr_t data)

{

	au_kcontext_t	*kctx;

	kctx = GET_KCTX_PZ;