/*
 * 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"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pwd.h>
#include <string.h>
#include <libintl.h>
#include <locale.h>
#include <deflt.h>
#include <user_attr.h>
#include <prof_attr.h>
#include <exec_attr.h>
#include <auth_attr.h>


#define	EXIT_OK		0
#define	EXIT_FATAL	1
#define	EXIT_NON_FATAL	2

#define	MAX_LINE_LEN	80		/* max 80 chars per line of output */
#define	TMP_BUF_LEN	2048		/* size of temp string buffer */

#define	PRINT_DEFAULT	0x0000
#define	PRINT_NAME	0x0010
#define	PRINT_LONG	0x0020

#ifndef TEXT_DOMAIN			/* Should be defined by cc -D */
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

#define	PROFLIST_SEP	","


static void usage();
static int show_profs(char *, int);
static int list_profs(userattr_t *, int);
static void print_profs_long(char *, void *, int);
static void print_profs(char *, char **, int, int);
static void format_attr(int *, int, char *);
static void getProfiles(char *, char **, int *);
static void getDefaultProfiles(char **, int *);

static char *progname = "profiles";

int
main(int argc, char *argv[])
{
	extern int	optind;
	register int	c;
	register int	status = EXIT_OK;
	int		print_flag = PRINT_DEFAULT;

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "l")) != EOF) {
		switch (c) {
		case 'l':
			print_flag |= PRINT_LONG;
			break;
		default:
			usage();
			return (EXIT_FATAL);
		}
	}
	argc -= optind;
	argv += optind;

	if (*argv == NULL) {
		status = show_profs((char *)NULL, print_flag);
	} else {
		do {
			status = show_profs(*argv, print_flag);
			if (status == EXIT_FATAL) {
				break;
			}
		} while (*++argv);
	}
	status = (status == EXIT_OK) ? status : EXIT_FATAL;

	return (status);
}


static int
show_profs(char *username, int print_flag)
{
	register int		status = EXIT_OK;
	register struct passwd	*pw;
	register userattr_t	*user;
	char			*profArray[MAXPROFS];
	int			profcnt = 0;
	execattr_t		*exec;

	if (username == NULL) {
		if ((pw = getpwuid(getuid())) == NULL) {
			status = EXIT_NON_FATAL;
			(void) fprintf(stderr, "%s: ", progname);
			(void) fprintf(stderr, gettext("No passwd entry\n"));
			return (status);
		}
		username = pw->pw_name;
	} else if ((pw = getpwnam(username)) == NULL) {
		status = EXIT_NON_FATAL;
		(void) fprintf(stderr, "%s: %s : ", progname, username);
		(void) fprintf(stderr, gettext("No such user\n"));
		return (status);
	}
	if (username != NULL) {
		if ((user = getusernam(username)) != NULL) {
			status = list_profs(user, print_flag);
		} else {
			getDefaultProfiles(profArray, &profcnt);
			if (profcnt == 0) {
				status = EXIT_NON_FATAL;
			} else {
				if (print_flag & PRINT_LONG) {
					exec = getexecuser(username, KV_COMMAND,
					    NULL, GET_ALL);
					print_profs_long(username,
					    exec, print_flag);
					free_execattr(exec);
				} else {
					print_profs(username, profArray,
					    print_flag, profcnt);
				}
			}
		}
	}

	if (status == EXIT_NON_FATAL) {
		(void) fprintf(stderr, "%s: %s : ", progname, username);
		(void) fprintf(stderr, gettext("No profiles\n"));
	}

	return (status);
}


static int
list_profs(userattr_t *user, int print_flag)
{
	register int	status = EXIT_OK;
	char		*proflist = (char *)NULL;
	execattr_t	*exec = (execattr_t *)NULL;
	char		*profArray[MAXPROFS];
	int		profcnt = 0;

	if (print_flag & PRINT_LONG) {
		exec = getexecuser(user->name, KV_COMMAND, NULL, GET_ALL);
		if (exec == NULL) {
			status = EXIT_NON_FATAL;
		}
	} else {
		proflist = kva_match(user->attr, USERATTR_PROFILES_KW);
		if (proflist != NULL) {
			getProfiles(proflist, profArray, &profcnt);
		}
		/* Also get any default profiles */
		getDefaultProfiles(profArray, &profcnt);
		if (profcnt == 0) {
			status = EXIT_NON_FATAL;
		}
	}
	if (status == EXIT_OK) {
		if (print_flag & PRINT_LONG) {
			print_profs_long(user->name, exec, print_flag);
			free_execattr(exec);
		} else {
			print_profs(user->name, profArray,
			    print_flag, profcnt);
		}
	}
	free_userattr(user);

	return (status);
}


static void
print_profs_long(char *user, void *data, int print_flag)
{

	register int		i;
	register int		len;
	int			outlen;
	char			tmpstr[TMP_BUF_LEN];
	register char		*empty = "";
	register char		*lastname = empty;
	register char		*key;
	register char		*val;
	register kv_t		*kv_pair;
	register execattr_t	*exec;

	if (print_flag & PRINT_NAME) {
		(void) printf("%s : ", user);
	}
	(void) printf("\n");
	exec = (execattr_t *)data;
	while (exec != (execattr_t *)NULL) {
		if (strcmp(exec->name, lastname) != NULL) {
			(void) snprintf(tmpstr, sizeof (tmpstr),
			    "      %s:", exec->name);
			(void) printf("%s\n", tmpstr);
		}
		(void) snprintf(tmpstr, sizeof (tmpstr),
		    "          %s    ", exec->id);
		outlen = strlen(tmpstr);
		len = outlen;
		(void) printf("%s", tmpstr);
		if ((exec->attr == NULL) ||
		    (kv_pair = exec->attr->data) == NULL) {
			(void) printf("\n");
			lastname = exec->name;
			exec = exec->next;
			continue;
		}
		for (i = 0; i < exec->attr->length; i++) {
			key = kv_pair[i].key;
			val = kv_pair[i].value;
			if ((key == NULL) || (val == NULL)) {
				break;
			}
			if (i > 0) {
				(void) strlcpy(tmpstr, ", ", TMP_BUF_LEN);
				format_attr(&outlen, len, tmpstr);
			}
			(void) snprintf(tmpstr, sizeof (tmpstr), "%s=%s",
			    key, val);
			format_attr(&outlen, len, tmpstr);
		}
		(void) printf("\n");
		lastname = exec->name;
		exec = exec->next;
	}
}


static void
format_attr(int *outlen, int len, char *str)
{
	int newline = 0;

	if ((MAX_LINE_LEN - *outlen) < strlen(str)) {
		newline = 1;
	}
	if (newline) {
		(void) printf("\n");
		len += strlen(str);
		(void) printf("%*s", len, str);
		*outlen = len;
	} else {
		*outlen += strlen(str);
		(void) printf("%s", str);
	}
}

static void
usage()
{
	(void) fprintf(stderr,
	    gettext("  usage: profiles [-l] [user1 user2 ...]\n"));
}

static void
getProfiles(char *profiles, char **profArray, int *profcnt) {

	char		*prof;
	char		*lasts;

	for (prof = (char *)strtok_r(profiles, PROFLIST_SEP, &lasts);
	    prof != NULL;
	    prof = (char *)strtok_r(NULL, PROFLIST_SEP, &lasts)) {

		getproflist(prof, profArray, profcnt);

	}
}

static void
print_profs(char *user, char **profnames, int print_flag, int profcnt)
{

	int i;

	if (print_flag & PRINT_NAME) {
		(void) printf("%s : ", user);
	}

	for (i = 0; i < profcnt; i++) {
		(void) printf("%s\n", profnames[i]);
	}

	free_proflist(profnames, profcnt);
}

/*
 * Get the list of default profiles from /etc/security/policy.conf
 */
static void
getDefaultProfiles(char **profArray, int *profcnt)
{
	char *profs = NULL;

	if (defopen(AUTH_POLICY) == NULL) {
		profs = defread(DEF_PROF);
	}

	if (profs != NULL) {
		getProfiles(profs, profArray, profcnt);
	}

}