/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


#include	<stdio.h>
#include	<string.h>
#include	<strings.h>
#include	<stdlib.h>
#include	<unistd.h>
#include	<sys/types.h>
#include	<limits.h>
#include	<dirent.h>
#include	<fcntl.h>
#include	<sys/time.h>
#include	<sys/procset.h>
#include	<sys/priocntl.h>
#include	<sys/task.h>
#include	<procfs.h>
#include	<project.h>
#include	<errno.h>
#include	<zone.h>
#include	<libcontract_priv.h>

#include "priocntl.h"

/*LINTLIBRARY*/

/*
 * Utility functions for priocntl command.
 */

static char	*procdir = "/proc";

/*PRINTFLIKE1*/
void
fatalerr(format, a1, a2, a3, a4, a5)
char	*format;
int	a1, a2, a3, a4, a5;
{
	(void) fprintf(stderr, format, a1, a2, a3, a4, a5);
	exit(1);
}


/*
 * Structure defining idtypes known to the priocntl command
 * along with the corresponding names and a liberal guess
 * of the max number of procs sharing any given ID of that type.
 * The idtype values themselves are defined in <sys/procset.h>.
 */
static struct idtypes {
	idtype_t	idtype;
	char		*idtypnm;
} idtypes [] = {
	{ P_PID,	"pid"	},
	{ P_PPID,	"ppid"	},
	{ P_PGID,	"pgid"	},
	{ P_SID,	"sid"	},
	{ P_CID,	"class"	},
	{ P_UID,	"uid"	},
	{ P_GID,	"gid"	},
	{ P_PROJID,	"projid" },
	{ P_TASKID,	"taskid" },
	{ P_ZONEID,	"zoneid" },
	{ P_CTID,	"ctid" },
	{ P_ALL,	"all"	}
};

#define	IDCNT	(sizeof (idtypes) / sizeof (struct idtypes))


int
str2idtyp(idtypnm, idtypep)
char		*idtypnm;
idtype_t	*idtypep;
{
	register struct idtypes	*curp;
	register struct idtypes	*endp;

	for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) {
		if (strcmp(curp->idtypnm, idtypnm) == 0) {
			*idtypep = curp->idtype;
			return (0);
		}
	}
	return (-1);
}


int
idtyp2str(idtype, idtypnm)
idtype_t	idtype;
char		*idtypnm;
{
	register struct idtypes	*curp;
	register struct idtypes	*endp;

	for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) {
		if (idtype == curp->idtype) {
			(void) strncpy(idtypnm, curp->idtypnm, PC_IDTYPNMSZ);
			return (0);
		}
	}
	return (-1);
}


/*
 * Compare two IDs for equality.
 */
int
idcompar(id1p, id2p)
id_t	*id1p;
id_t	*id2p;
{
	if (*id1p == *id2p)
		return (0);
	else
		return (-1);
}


id_t
clname2cid(clname)
char	*clname;
{
	pcinfo_t	pcinfo;

	(void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ);
	if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
		return ((id_t)-1);
	return (pcinfo.pc_cid);
}


int
getmyid(idtype, idptr)
idtype_t	idtype;
id_t		*idptr;
{
	pcinfo_t	pcinfo;

	switch (idtype) {

	case P_PID:
		*idptr = (id_t)getpid();
		break;

	case P_PPID:
		*idptr = (id_t)getppid();
		break;

	case P_PGID:
		*idptr = (id_t)getpgrp();
		break;

	case P_SID:
		*idptr = (id_t)getsid(getpid());
		break;

	case P_CID:
		if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
		    PC_KY_CLNAME, pcinfo.pc_clname, 0) == -1 ||
		    priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
			return (-1);

		*idptr = pcinfo.pc_cid;
		break;

	case P_UID:
		*idptr = (id_t)getuid();
		break;

	case P_GID:
		*idptr = (id_t)getgid();
		break;

	case P_PROJID:
		*idptr = (id_t)getprojid();
		break;

	case P_TASKID:
		*idptr = (id_t)gettaskid();
		break;

	case P_ZONEID:
		*idptr = (id_t)getzoneid();
		break;

	case P_CTID: {
		ctid_t id = getctid();
		if (id == -1)
			return (-1);
		*idptr = id;
		break;
	}

	default:
		return (-1);
	}
	return (0);
}


int
getmyidstr(idtype, idstr)
idtype_t	idtype;
char		*idstr;
{
	char		clname[PC_CLNMSZ];

	switch (idtype) {

	case P_PID:
		itoa((long)getpid(), idstr);
		break;

	case P_PPID:
		itoa((long)getppid(), idstr);
		break;

	case P_PGID:
		itoa((long)getpgrp(), idstr);
		break;
	case P_SID:
		itoa((long)getsid(getpid()), idstr);
		break;

	case P_CID:
		if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
		    PC_KY_CLNAME, clname, 0) == -1)
			return (-1);
		(void) strncpy(idstr, clname, PC_CLNMSZ);
		break;

	case P_UID:
		itoa((long)getuid(), idstr);
		break;

	case P_GID:
		itoa((long)getgid(), idstr);
		break;

	case P_PROJID:
		itoa((long)getprojid(), idstr);
		break;

	case P_TASKID:
		itoa((long)gettaskid(), idstr);
		break;

	case P_ZONEID:
		itoa((long)getzoneid(), idstr);
		break;

	case P_CTID: {
		id_t id;
		if ((id = getctid()) == -1)
			return (-1);
		itoa((long)id, idstr);
		break;
	}

	default:
		return (-1);
	}
	return (0);
}

/*
 * Look for pids with "upri > uprilim" in the set specified by idtype/id.
 * If upri exceeds uprilim then print a warning.
 */
int
verifyupri(idtype_t idtype, id_t id, char *clname, int key,
	pri_t upri, char *basenm)
{
	psinfo_t		prinfo;
	prcred_t		prcred;
	DIR			*dirp;
	struct dirent		*dentp;
	char			pname[MAXNAMLEN];
	char			*fname;
	int			procfd;
	int			saverr;
	pri_t			uprilim;
	int			verify;
	int			error = 0;

	if (idtype == P_PID) {
		if (priocntl(P_PID, id, PC_GETXPARMS, clname, key,
		    &uprilim, 0) == -1)
			error = -1;
		else if (upri > uprilim)
			(void) fprintf(stderr,
			    "%s: Specified user priority %d exceeds"
			    " limit %d; set to %d (pid %d)\n",
			    basenm, upri, uprilim, uprilim, (int)id);

		return (error);
	}

	/*
	 * Look for the processes in the set specified by idtype/id.
	 * We read the /proc/<pid>/psinfo file to get the necessary
	 * process information.
	 */

	if ((dirp = opendir(procdir)) == NULL)
		fatalerr("%s: Can't open PROC directory %s\n",
		    basenm, procdir);

	while ((dentp = readdir(dirp)) != NULL) {
		if (dentp->d_name[0] == '.')	/* skip . and .. */
			continue;

		(void) snprintf(pname, MAXNAMLEN, "%s/%s/",
		    procdir, dentp->d_name);
		fname = pname + strlen(pname);
retry:
		(void) strncpy(fname, "psinfo", strlen("psinfo") + 1);
		if ((procfd = open(pname, O_RDONLY)) < 0)
			continue;
		if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) {
			saverr = errno;
			(void) close(procfd);
			if (saverr == EAGAIN)
				goto retry;
			continue;
		}
		(void) close(procfd);

		if (idtype == P_UID || idtype == P_GID) {
			(void) strncpy(fname, "cred", strlen("cred") + 1);
			if ((procfd = open(pname, O_RDONLY)) < 0 ||
			    read(procfd, &prcred, sizeof (prcred)) !=
			    sizeof (prcred)) {
				saverr = errno;
				(void) close(procfd);
				if (saverr == EAGAIN)
					goto retry;
				continue;
			}
			(void) close(procfd);
		}

		if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
			continue;

		/*
		 * The lwp must be in the correct class.
		 */
		if (strncmp(clname, prinfo.pr_lwp.pr_clname, PC_CLNMSZ) != 0)
			continue;

		verify = 0;
		switch (idtype) {

		case P_PPID:
			if (id == (id_t)prinfo.pr_ppid)
				verify++;
			break;

		case P_PGID:
			if (id == (id_t)prinfo.pr_pgid)
				verify++;
			break;

		case P_SID:
			if (id == (id_t)prinfo.pr_sid)
				verify++;
			break;

		case P_UID:
			if (id == (id_t)prcred.pr_euid)
				verify++;
			break;

		case P_GID:
			if (id == (id_t)prcred.pr_egid)
				verify++;
			break;

		case P_PROJID:
			if (id == (id_t)prinfo.pr_projid)
				verify++;
			break;

		case P_TASKID:
			if (id == (id_t)prinfo.pr_taskid)
				verify++;
			break;

		case P_ZONEID:
			if (id == (id_t)prinfo.pr_zoneid)
				verify++;
			break;

		case P_CTID:
			if (id == (id_t)prinfo.pr_contract)
				verify++;
			break;

		case P_CID:
		case P_ALL:
			verify++;
			break;

		default:
			fatalerr("%s: Bad idtype %d in verifyupri()\n",
			    basenm, idtype);
		}

		if (verify) {
			if (priocntl(P_PID, prinfo.pr_pid, PC_GETXPARMS,
			    clname, key, &uprilim, 0) == -1)
				error = -1;
			else if (upri > uprilim)
				(void) fprintf(stderr,
				    "%s: Specified user priority %d exceeds"
				    " limit %d; set to %d (pid %d)\n",
				    basenm, upri, uprilim, uprilim,
				    (int)prinfo.pr_pid);
		}
	}
	(void) closedir(dirp);

	return (error);
}


/*
 * Read a list of pids from a stream.
 */
pid_t *
read_pidlist(size_t *npidsp, FILE *filep)
{
	size_t	nitems;
	pid_t	*pidlist = NULL;

	*npidsp = 0;

	do {
		if ((pidlist = (pid_t *)realloc(pidlist,
		    (*npidsp + NPIDS) * sizeof (pid_t))) == NULL)
			return (NULL);

		nitems = fread(pidlist + *npidsp, sizeof (pid_t), NPIDS, filep);
		if (ferror(filep))
			return (NULL);

		*npidsp += nitems;
	} while (nitems == NPIDS);

	return (pidlist);
}


void
free_pidlist(pid_t *pidlist)
{
	free(pidlist);
}


long
str2num(char *p, long min, long max)
{
	long val;
	char *q;
	errno = 0;

	val = strtol(p, &q, 10);
	if (errno != 0 || q == p || *q != '\0' || val < min || val > max)
		errno = EINVAL;

	return (val);
}


/*
 * itoa() and reverse() taken almost verbatim from K & R Chapter 3.
 */
static void	reverse();

/*
 * itoa(): Convert n to characters in s.
 */
void
itoa(n, s)
long	n;
char	*s;
{
	long	i, sign;

	if ((sign = n) < 0)	/* record sign */
		n = -n;		/* make sign positive */
	i = 0;
	do {	/* generate digits in reverse order */
		s[i++] = n % 10 + '0';	/* get next digit */
	} while ((n /= 10) > 0);	/* delete it */
	if (sign < 0)
		s[i++] = '-';
	s[i] = '\0';
	reverse(s);
}


/*
 * reverse(): Reverse string s in place.
 */
static void
reverse(s)
char	*s;
{
	int	c, i, j;

	for (i = 0, j = strlen(s) - 1; i < j; i++, j--) {
		c = s[i];
		s[i] = s[j];
		s[j] = (char)c;
	}
}


/*
 * The following routine was removed from libc (libc/port/gen/hrtnewres.c).
 * It has also been added to disadmin, so if you fix it here, you should
 * also probably fix it there. In the long term, this should be recoded to
 * not be hrt'ish.
 */

/*
 *	Convert interval expressed in htp->hrt_res to new_res.
 *
 *	Calculate: (interval * new_res) / htp->hrt_res  rounding off as
 *		specified by round.
 *
 *	Note:	All args are assumed to be positive.  If
 *	the last divide results in something bigger than
 *	a long, then -1 is returned instead.
 */

int
_hrtnewres(htp, new_res, round)
register hrtimer_t *htp;
register ulong_t new_res;
long round;
{
	register long  interval;
	longlong_t	dint;
	longlong_t	dto_res;
	longlong_t	drem;
	longlong_t	dfrom_res;
	longlong_t	prod;
	longlong_t	quot;
	register long	numerator;
	register long	result;
	ulong_t		modulus;
	ulong_t		twomodulus;
	long		temp;

	if (new_res > NANOSEC || htp->hrt_rem < 0)
		return (-1);

	if (htp->hrt_rem >= htp->hrt_res) {
		htp->hrt_secs += htp->hrt_rem / htp->hrt_res;
		htp->hrt_rem = htp->hrt_rem % htp->hrt_res;
	}

	interval = htp->hrt_rem;
	if (interval == 0) {
		htp->hrt_res = new_res;
		return (0);
	}

	/*
	 *	Try to do the calculations in single precision first
	 *	(for speed).  If they overflow, use double precision.
	 *	What we want to compute is:
	 *
	 *		(interval * new_res) / hrt->hrt_res
	 */

	numerator = interval * new_res;

	if (numerator / new_res  ==  interval) {

		/*
		 *	The above multiply didn't give overflow since
		 *	the division got back the original number.  Go
		 *	ahead and compute the result.
		 */

		result = numerator / htp->hrt_res;

		/*
		 *	For HRT_RND, compute the value of:
		 *
		 *		(interval * new_res) % htp->hrt_res
		 *
		 *	If it is greater than half of the htp->hrt_res,
		 *	then rounding increases the result by 1.
		 *
		 *	For HRT_RNDUP, we increase the result by 1 if:
		 *
		 *		result * htp->hrt_res != numerator
		 *
		 *	because this tells us we truncated when calculating
		 *	result above.
		 *
		 *	We also check for overflow when incrementing result
		 *	although this is extremely rare.
		 */

		if (round == HRT_RND) {
			modulus = numerator - result * htp->hrt_res;
			if ((twomodulus = 2 * modulus) / 2 == modulus) {

				/*
				 * No overflow (if we overflow in calculation
				 * of twomodulus we fall through and use
				 * double precision).
				 */
				if (twomodulus >= htp->hrt_res) {
					temp = result + 1;
					if (temp - 1 == result)
						result++;
					else
						return (-1);
				}
				htp->hrt_res = new_res;
				htp->hrt_rem = result;
				return (0);
			}
		} else if (round == HRT_RNDUP) {
			if (result * htp->hrt_res != numerator) {
				temp = result + 1;
				if (temp - 1 == result)
					result++;
				else
					return (-1);
			}
			htp->hrt_res = new_res;
			htp->hrt_rem = result;
			return (0);
		} else {	/* round == HRT_TRUNC */
			htp->hrt_res = new_res;
			htp->hrt_rem = result;
			return (0);
		}
	}

	/*
	 *	We would get overflow doing the calculation is
	 *	single precision so do it the slow but careful way.
	 *
	 *	Compute the interval times the resolution we are
	 *	going to.
	 */

	dint = interval;
	dto_res = new_res;
	prod = dint * dto_res;

	/*
	 *	For HRT_RND the result will be equal to:
	 *
	 *		((interval * new_res) + htp->hrt_res / 2) / htp->hrt_res
	 *
	 *	and for HRT_RNDUP we use:
	 *
	 *		((interval * new_res) + htp->hrt_res - 1) / htp->hrt_res
	 *
	 * 	This is a different but equivalent way of rounding.
	 */

	if (round == HRT_RND) {
		drem = htp->hrt_res / 2;
		prod = prod + drem;
	} else if (round == HRT_RNDUP) {
		drem = htp->hrt_res - 1;
		prod = prod + drem;
	}

	dfrom_res = htp->hrt_res;
	quot = prod / dfrom_res;

	/*
	 *	If the quotient won't fit in a long, then we have
	 *	overflow.  Otherwise, return the result.
	 */

	if (quot > UINT_MAX) {
		return (-1);
	} else {
		htp->hrt_res = new_res;
		htp->hrt_rem = (int)quot;
		return (0);
	}
}