/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/acct.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <fcntl.h>
#include <exacct.h>
#include <pwd.h>
#include <grp.h>
#include <project.h>
#include <stdlib.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#ifndef _LP64
#define	FMT_UINT64	"%-15llu"
#else
#define	FMT_UINT64	"%-15lu"
#endif

#define	MAX_DEPTH	25		/* maximum depth level */

static int vflag = 0;

typedef struct catalog_item {
	int	type;
	char	*name;
} catalog_item_t;

/*
 * The actual constants are defined in <sys/exacct_catalog.h>.
 */
static catalog_item_t catalog[] = {
	{ EXD_VERSION,			"version" },
	{ EXD_FILETYPE,			"filetype" },
	{ EXD_CREATOR,			"creator" },
	{ EXD_HOSTNAME,			"hostname" },

	{ EXD_GROUP_HEADER,		"group-header" },
	{ EXD_GROUP_PROC,		"group-proc" },
	{ EXD_GROUP_TASK,		"group-task" },
	{ EXD_GROUP_LWP,		"group-lwp" },
	{ EXD_GROUP_FLOW,		"group-flow" },
	{ EXD_GROUP_PROC_TAG,		"group-proc-tag" },
	{ EXD_GROUP_TASK_TAG,		"group-task-tag" },
	{ EXD_GROUP_LWP_TAG,		"group-lwp-tag" },
	{ EXD_GROUP_PROC_PARTIAL,	"group-proc-partial" },
	{ EXD_GROUP_TASK_PARTIAL,	"group-task-partial" },
	{ EXD_GROUP_TASK_INTERVAL,	"group-task-interval" },

	{ EXD_PROC_PID,			"pid" },
	{ EXD_PROC_ANCPID, 		"ppid" },
	{ EXD_PROC_UID,			"uid" },
	{ EXD_PROC_GID,			"gid" },
	{ EXD_PROC_TASKID,		"taskid" },
	{ EXD_PROC_PROJID,		"projid" },
	{ EXD_PROC_HOSTNAME,		"hostname" },
	{ EXD_PROC_COMMAND,		"command" },
	{ EXD_PROC_WAIT_STATUS,		"wait-status" },
	{ EXD_PROC_START_SEC,		"start-sec" },
	{ EXD_PROC_START_NSEC,		"start-nsec" },
	{ EXD_PROC_FINISH_SEC,		"finish-sec" },
	{ EXD_PROC_FINISH_NSEC,		"finish-nsec" },
	{ EXD_PROC_CPU_USER_SEC,	"cpu-user-sec" },
	{ EXD_PROC_CPU_USER_NSEC,	"cpu-user-nsec" },
	{ EXD_PROC_CPU_SYS_SEC,		"cpu-sys-sec" },
	{ EXD_PROC_CPU_SYS_NSEC,	"cpu-sys-nsec" },
	{ EXD_PROC_TTY_MAJOR,		"tty-major" },
	{ EXD_PROC_TTY_MINOR,		"tty-minor" },
	{ EXD_PROC_FAULTS_MAJOR,	"faults-major" },
	{ EXD_PROC_FAULTS_MINOR,	"faults-minor" },
	{ EXD_PROC_MESSAGES_RCV,	"msgs-recv" },
	{ EXD_PROC_MESSAGES_SND,	"msgs-snd" },
	{ EXD_PROC_BLOCKS_IN,		"blocks-in" },
	{ EXD_PROC_BLOCKS_OUT,		"blocks-out" },
	{ EXD_PROC_CHARS_RDWR,		"chars-rdwr" },
	{ EXD_PROC_CONTEXT_VOL,		"ctxt-vol" },
	{ EXD_PROC_CONTEXT_INV,		"ctxt-inv" },
	{ EXD_PROC_SIGNALS,		"signals" },
	{ EXD_PROC_SWAPS,		"swaps" },
	{ EXD_PROC_SYSCALLS,		"syscalls" },
	{ EXD_PROC_TAG,			"proc-tag" },
	{ EXD_PROC_ACCT_FLAGS,		"acctflags" },
	{ EXD_PROC_ZONENAME,		"zone" },
	{ EXD_PROC_MEM_RSS_AVG_K,	"memory-rss-avg-k" },
	{ EXD_PROC_MEM_RSS_MAX_K,	"memory-rss-max-k" },

	{ EXD_TASK_TASKID,		"taskid" },
	{ EXD_TASK_ANCTASKID,		"anctaskid" },
	{ EXD_TASK_PROJID,		"projid" },
	{ EXD_TASK_HOSTNAME,		"hostname" },
	{ EXD_TASK_START_SEC,		"start-sec" },
	{ EXD_TASK_START_NSEC,		"start-nsec" },
	{ EXD_TASK_FINISH_SEC,		"finish-sec" },
	{ EXD_TASK_FINISH_NSEC,		"finish-nsec" },
	{ EXD_TASK_CPU_USER_SEC,	"cpu-user-sec" },
	{ EXD_TASK_CPU_USER_NSEC,	"cpu-user-nsec" },
	{ EXD_TASK_CPU_SYS_SEC,		"cpu-sys-sec" },
	{ EXD_TASK_CPU_SYS_NSEC,	"cpu-sys-nsec" },
	{ EXD_TASK_FAULTS_MAJOR,	"faults-major" },
	{ EXD_TASK_FAULTS_MINOR,	"faults-minor" },
	{ EXD_TASK_MESSAGES_RCV,	"msgs-recv" },
	{ EXD_TASK_MESSAGES_SND,	"msgs-snd" },
	{ EXD_TASK_BLOCKS_IN,		"blocks-in" },
	{ EXD_TASK_BLOCKS_OUT,		"blocks-out" },
	{ EXD_TASK_CHARS_RDWR,		"chars-rdwr" },
	{ EXD_TASK_CONTEXT_VOL,		"ctxt-vol" },
	{ EXD_TASK_CONTEXT_INV,		"ctxt-inv" },
	{ EXD_TASK_SIGNALS,		"signals" },
	{ EXD_TASK_SWAPS,		"swaps" },
	{ EXD_TASK_SYSCALLS,		"syscalls" },
	{ EXD_TASK_TAG,			"task-tag" },
	{ EXD_TASK_ZONENAME,		"zone" },

	{ EXD_FLOW_V4SADDR,		"src-addr-v4" },
	{ EXD_FLOW_V4DADDR,		"dest-addr-v4" },
	{ EXD_FLOW_V6SADDR,		"src-addr-v6" },
	{ EXD_FLOW_V6DADDR,		"dest-addr-v6" },
	{ EXD_FLOW_SPORT,		"src-port" },
	{ EXD_FLOW_DPORT,		"dest-port" },
	{ EXD_FLOW_PROTOCOL,		"protocol" },
	{ EXD_FLOW_DSFIELD,		"diffserv-field" },
	{ EXD_FLOW_NBYTES,		"total-bytes" },
	{ EXD_FLOW_NPKTS,		"total-packets" },
	{ EXD_FLOW_CTIME,		"creation-time" },
	{ EXD_FLOW_LSEEN,		"last-seen" },
	{ EXD_FLOW_PROJID,		"projid" },
	{ EXD_FLOW_UID,			"uid" },
	{ EXD_FLOW_ANAME,		"action-name" },

	{ EXD_NONE,			"none" }
};

static void disp_obj(ea_object_t *o, int indent);

/*
 * Convert catalog ID into catalog name.
 */
static char *
catalog_name(int type)
{
	int i = 0;

	while (catalog[i].type != EXD_NONE) {
		if (catalog[i].type == type)
			return (catalog[i].name);
		i++;
	}

	return ("unknown");
}

/*
 * Display port information, if available
 */
static void
disp_port(uint16_t port)
{
	struct servent *port_info;

	port_info = getservbyport(htons(port), NULL);
	if (port_info != NULL) {
		(void) printf("%s", port_info->s_name);
	}
}

/*
 * Display host name for a given IP address if available.
 */
static void
disp_host(char *addr, int family)
{
	struct hostent *phe;
	uint_t len;
	int error_num;

	len = (family == AF_INET) ? sizeof (struct in_addr) :
	    sizeof (struct in6_addr);

	if ((phe = getipnodebyaddr(addr, len, family, &error_num)) != NULL) {
		(void) printf("%s", phe->h_name);
	}
}

/*
 * Display protocol information, if available.
 */
static void
disp_proto(uint8_t protocol)
{
	struct protoent *proto_ent;

	proto_ent = getprotobynumber(protocol);
	if (proto_ent != NULL) {
		(void) printf("%s", proto_ent->p_name);
	}

}

/*
 * Display recursively exacct objects in a given embedded group.
 */
static void
disp_embedded_group(ea_object_t *eo, int indent)
{
	while (eo != NULL) {
		disp_obj(eo, indent + 1);
		if (eo->eo_type == EO_GROUP)
			disp_embedded_group(eo->eo_group.eg_objs, indent + 1);
		eo = eo->eo_next;
	}
}

/*
 * Display the data stored in a given exacct object.
 */
static void
disp_obj(ea_object_t *o, int indent)
{
	char objname[30] = "                              ";
	int eol = 1;

	if (indent > MAX_DEPTH) {
		objname[0] = '>';
		indent = 1;
	}

	(void) printf("%6x\t", (o->eo_catalog & EXD_DATA_MASK));
	(void) snprintf(objname + indent, 30 - indent, "%-s",
	    catalog_name(o->eo_catalog & EXD_DATA_MASK));
	(void) printf("%-30s\t", objname);

	switch (o->eo_catalog & EXT_TYPE_MASK) {
	case EXT_UINT8:
		(void) printf("%-15u", o->eo_item.ei_uint8);
		if (vflag &&
		    ((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_PROTOCOL)) {
			disp_proto(o->eo_item.ei_uint8);
		}
		break;
	case EXT_UINT16:
		(void) printf("%-15u", o->eo_item.ei_uint16);
		if (vflag &&
		    (((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_SPORT) ||
		    ((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_DPORT))) {
			disp_port(o->eo_item.ei_uint16);
		}
		break;
	case EXT_UINT32:
		switch (o->eo_catalog & EXD_DATA_MASK) {
		case EXD_PROC_WAIT_STATUS:
			{
				int wstat = o->eo_item.ei_uint32;

				if (vflag) {
					if (WIFEXITED(wstat))
						(void) printf("%-14d exit",
						    WEXITSTATUS(wstat));
					else if (WIFSIGNALED(wstat))
						(void) printf("%14d, signal",
						    WTERMSIG(wstat));
					else
						(void) printf("%d", wstat);
				} else {
					(void) printf("%d", wstat);
				}
			}
			break;
		case EXD_PROC_UID:
			{
				uid_t uid = o->eo_item.ei_uint32;

				(void) printf("%-15u", uid);
				if (vflag) {
					struct passwd *pwd;
					if ((pwd = getpwuid(uid)) != NULL)
						(void) printf("%s",
						    pwd->pw_name);
				}
			}
			break;
		case EXD_PROC_GID:
			{
				gid_t gid = o->eo_item.ei_uint32;

				(void) printf("%-15u", gid);
				if (vflag) {
					struct group *grp;
					if ((grp = getgrgid(gid)) != NULL)
						(void) printf("%s",
						    grp->gr_name);
				}
			}
			break;
		case EXD_PROC_PROJID:
		case EXD_TASK_PROJID:
			{
				projid_t projid = o->eo_item.ei_uint32;

				(void) printf("%-15lu", projid);
				if (vflag) {
					struct project proj;
					char projbuf[PROJECT_BUFSZ];

					if (getprojbyid(projid, &proj, projbuf,
					    PROJECT_BUFSZ) != NULL)
						(void) printf("%s",
						    proj.pj_name);
				}
			}
			break;
		case EXD_PROC_ACCT_FLAGS:
			{
				int flag = o->eo_item.ei_uint32;

				(void) printf("%-15u", flag);
				if (vflag) {
					if (flag & AFORK)
						(void) printf("FORK ");
					if (flag & ASU)
						(void) printf("SU");
				}
			}
			break;
		case EXD_FLOW_V4SADDR:
			/* FALLTHRU */
		case EXD_FLOW_V4DADDR:
			{
				char str[INET_ADDRSTRLEN];
				uint32_t addr = htonl(o->eo_item.ei_uint32);

				(void) printf("%-15s",
				    inet_ntop(AF_INET, &addr, str,
				    INET_ADDRSTRLEN));
				if (vflag) {
					disp_host((char *)&addr, AF_INET);
				}
			}
			break;
		default:
			(void) printf("%u", o->eo_item.ei_uint32);
		}
		break;
	case EXT_UINT64:
		{
			time_t _time;
			char timebuf[20];

			(void) printf(FMT_UINT64, o->eo_item.ei_uint64);
			if (!vflag)
				break;
			if (ea_match_object_catalog(o, EXD_TASK_START_SEC) ||
			    ea_match_object_catalog(o, EXD_TASK_FINISH_SEC) ||
			    ea_match_object_catalog(o, EXD_PROC_START_SEC) ||
			    ea_match_object_catalog(o, EXD_PROC_FINISH_SEC) ||
			    ea_match_object_catalog(o, EXD_FLOW_LSEEN) ||
			    ea_match_object_catalog(o, EXD_FLOW_CTIME)) {
				_time = o->eo_item.ei_uint64;
				(void) strftime(timebuf, sizeof (timebuf),
				    "%D %T", localtime(&_time));
				(void) fputs(timebuf, stdout);
			}
		}
		break;
	case EXT_DOUBLE:
		(void) printf("%f", o->eo_item.ei_double);
		break;
	case EXT_STRING:
		(void) printf("\"%s\"", o->eo_item.ei_string);
		break;
	case EXT_RAW:
		switch (o->eo_catalog & EXD_DATA_MASK) {
		case EXD_FLOW_V6SADDR:
			/* FALLTHRU */
		case EXD_FLOW_V6DADDR:
			{
				in6_addr_t *addr;
				char str[INET6_ADDRSTRLEN];

				addr = (in6_addr_t *)o->eo_item.ei_raw;
				(void) printf("%-28s", inet_ntop(AF_INET6,
				    &addr->s6_addr, str, INET6_ADDRSTRLEN));
				if (vflag) {
					disp_host((char *)&addr->s6_addr,
					    AF_INET6);
				}

			}
			break;
		default:
			{
				ea_size_t size = o->eo_item.ei_size;
				char *buf = o->eo_item.ei_raw;
				uint64_t i;

				for (i = 0; i < size && i < 6; i++)
					(void) printf("0x%2X ", buf[i]);
				if (size > 6)
					(void) printf("...");
			}
		}
		break;
	case EXT_GROUP:
		(void) printf("[group of %u object(s)]", o->eo_group.eg_nobjs);
		break;
	case EXT_EXACCT_OBJECT:
		/*
		 * Embedded exacct records.
		 */
		{
			ea_object_type_t ot;
			ea_object_t *op;
			ea_object_t *eo;

			ot = ea_unpack_object(&op, EUP_ALLOC,
			    o->eo_item.ei_object, o->eo_item.ei_size);

			if (ot == EO_ERROR) {
				(void) printf("error: couldn't unpack embedded "
				    "object\n");
				break;
			}
			eol = 0;
			if (ot == EO_GROUP) {
				(void) printf("[embedded group of %u "
				    "object(s)]\n", op->eo_group.eg_nobjs);
				eo = op->eo_group.eg_objs;
				disp_embedded_group(eo, indent);
			} else {
				(void) printf("[embedded object]\n");
				disp_obj(op, indent);
			}
			ea_free_object(op, EUP_ALLOC);
		}
		break;
	default:
		(void) printf("[complex value]");
		break;
	}

	if (eol)
		(void) printf("\n");

}

/*
 * Read and display a group of exacct objects from the file.
 */
static void
disp_group(ea_file_t *ef, uint_t nobjs, int indent)
{
	uint_t i;

	for (i = 0; i < nobjs; i++) {
		ea_object_t scratch;
		int res;

		if ((res = ea_get_object(ef, &scratch)) == -1) {
			(void) fprintf(stderr,
			    "bad file: ea_get_object()==%d\n", res);
			exit(2);
		}

		disp_obj(&scratch, indent + 1);

		if (scratch.eo_type == EO_GROUP)
			disp_group(ef, scratch.eo_group.eg_nobjs, indent + 1);
		else
			(void) ea_free_item(&scratch, EUP_ALLOC);
	}
}

static void
usage()
{
	(void) fprintf(stderr, "Usage: exdump [-v] <file>\n");
	exit(2);
}

int
main(int argc, char *argv[])
{
	ea_file_t ef;
	ea_object_t scratch;
	char *fname;
	int opt;

	while ((opt = getopt(argc, argv, "v")) != EOF) {
		switch (opt) {
		case 'v':
			vflag = 1;
			break;
		default:
			usage();
		}
	}

	if (argc == optind)
		usage();
	if (argc > optind)
		fname = argv[optind++];
	if (argc > optind)
		usage();

	if (ea_open(&ef, fname, NULL,
	    vflag ? EO_NO_VALID_HDR : 0, O_RDONLY, 0) == -1) {
		(void) fprintf(stderr, "exdump: cannot open %s\n", fname);
		return (1);
	}

	bzero(&scratch, sizeof (ea_object_t));
	while (ea_get_object(&ef, &scratch) != -1) {
		disp_obj(&scratch, 0);
		if (scratch.eo_type == EO_GROUP)
			disp_group(&ef, scratch.eo_group.eg_nobjs, 0);
		else
			(void) ea_free_item(&scratch, EUP_ALLOC);
		(void) bzero(&scratch, sizeof (ea_object_t));
	}

	(void) ea_close(&ef);
	return (0);
}