#
# Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# Copyright (c) 2018, Joyent, Inc.

PROG		=	kproplog

OBJS		=	kproplog.o
DERIVED_OBJS	=	iprop_xdr.o

SRCS=	$(OBJS:.o=.c)
SRCS+=	$(DERIVED_OBJS:.o=.c)

RSRC=	kproplog.c

# Definitions needed to rpcgen iprop-related files
ISRC= iprop.h iprop_xdr.c
KRB5IPROPDIR= $(SRC)/cmd/krb5/iprop
CMD= grep -v "usr/src/cmd/krb5/iprop" > $@

include	../../Makefile.cmd
include $(SRC)/lib/gss_mechs/mech_krb5/Makefile.mech_krb5

TEXT_DOMAIN = SUNW_OST_OSCMD
POFILE	= kproplog.po
POFILES	= generic.po

LDFLAGS		+=	-R$(KRB5RUNPATH) $(KRUNPATH)
# Hammerhead: GNU ld needs rpath-link for transitive deps (libdyn, libkdb) via libkadm5clnt
LDFLAGS		+=	-Wl,-rpath-link,$(ROOT)/usr/lib/krb5
LDLIBS		+=	-L$(KRB5LIB) $(KLIB) -lnsl -lkdb -lkadm5clnt

CPPFLAGS	+=	-I. -I$(SRC)/lib/krb5 \
			-I$(KRB5IPROPDIR) \
			-I$(SRC)/lib/gss_mechs/mech_krb5/include \
			-I$(SRC)/uts/common/gssapi/mechs/krb5/include

CERRWARN	+=	-Wno-unused-variable
CERRWARN	+=	-Wno-unused-function
CERRWARN	+=	-Wno-implicit-function-declaration
# Hammerhead: Suppress xdr_longlong_t type mismatch warnings (iprop_xdr.c)
CERRWARN	+=	-Wno-incompatible-pointer-types

# not linted
SMATCH=off

all:		$(PROG)

$(PROG):	$(OBJS) $(DERIVED_OBJS)
	$(LINK.c) $(OBJS) $(DERIVED_OBJS) -o $@ $(LDLIBS)
	$(POST_PROCESS)

# Hammerhead: pre-generated (rpcgen + GNU cpp truncation bug)
# iprop.h and iprop_xdr.c are now committed source files.

# Explicitly state the dependancy on iprop.h
$(OBJS): iprop.h

install:	$(KRB5SBINPROG)

clean:
	$(RM) $(OBJS) $(DERIVED_OBJS)
	@# Hammerhead: do not delete pre-generated $(ISRC)

include ../../Makefile.targ

$(POFILE): $(DERIVED_FILES) .WAIT $(POFILES)
	$(RM) $@
	$(CAT) $(POFILES) > $@

generic.po:
	$(RM) messages.po
	$(XGETTEXT) $(XGETFLAGS) `$(GREP) -l gettext *.[ch]`
	$(SED) "/^domain/d" messages.po > $@
	$(RM) messages.po
/*
 * Please do not edit this file.
 * It was generated using rpcgen.
 */

#ifndef _IPROP_H_RPCGEN
#define	_IPROP_H_RPCGEN

#include <rpc/rpc.h>

typedef struct {
	u_int utf8str_t_len;
	char *utf8str_t_val;
} utf8str_t;

typedef uint32_t kdb_sno_t;

struct kdbe_time_t {
	uint32_t seconds;
	uint32_t useconds;
};
typedef struct kdbe_time_t kdbe_time_t;

struct kdbe_key_t {
	int32_t k_ver;
	int32_t k_kvno;
	struct {
		u_int k_enctype_len;
		int32_t *k_enctype_val;
	} k_enctype;
	struct {
		u_int k_contents_len;
		utf8str_t *k_contents_val;
	} k_contents;
};
typedef struct kdbe_key_t kdbe_key_t;

struct kdbe_data_t {
	int32_t k_magic;
	utf8str_t k_data;
};
typedef struct kdbe_data_t kdbe_data_t;

struct kdbe_princ_t {
	utf8str_t k_realm;
	struct {
		u_int k_components_len;
		kdbe_data_t *k_components_val;
	} k_components;
	int32_t k_nametype;
};
typedef struct kdbe_princ_t kdbe_princ_t;

struct kdbe_tl_t {
	int16_t tl_type;
	struct {
		u_int tl_data_len;
		char *tl_data_val;
	} tl_data;
};
typedef struct kdbe_tl_t kdbe_tl_t;

typedef struct {
	u_int kdbe_pw_hist_t_len;
	kdbe_key_t *kdbe_pw_hist_t_val;
} kdbe_pw_hist_t;

enum kdbe_attr_type_t {
	AT_ATTRFLAGS = 0,
	AT_MAX_LIFE = 1,
	AT_MAX_RENEW_LIFE = 2,
	AT_EXP = 3,
	AT_PW_EXP = 4,
	AT_LAST_SUCCESS = 5,
	AT_LAST_FAILED = 6,
	AT_FAIL_AUTH_COUNT = 7,
	AT_PRINC = 8,
	AT_KEYDATA = 9,
	AT_TL_DATA = 10,
	AT_LEN = 11,
	AT_MOD_PRINC = 12,
	AT_MOD_TIME = 13,
	AT_MOD_WHERE = 14,
	AT_PW_LAST_CHANGE = 15,
	AT_PW_POLICY = 16,
	AT_PW_POLICY_SWITCH = 17,
	AT_PW_HIST_KVNO = 18,
	AT_PW_HIST = 19
};
typedef enum kdbe_attr_type_t kdbe_attr_type_t;

struct kdbe_val_t {
	kdbe_attr_type_t av_type;
	union {
		uint32_t av_attrflags;
		uint32_t av_max_life;
		uint32_t av_max_renew_life;
		uint32_t av_exp;
		uint32_t av_pw_exp;
		uint32_t av_last_success;
		uint32_t av_last_failed;
		uint32_t av_fail_auth_count;
		kdbe_princ_t av_princ;
		struct {
			u_int av_keydata_len;
			kdbe_key_t *av_keydata_val;
		} av_keydata;
		struct {
			u_int av_tldata_len;
			kdbe_tl_t *av_tldata_val;
		} av_tldata;
		int16_t av_len;
		uint32_t av_pw_last_change;
		kdbe_princ_t av_mod_princ;
		uint32_t av_mod_time;
		utf8str_t av_mod_where;
		utf8str_t av_pw_policy;
		bool_t av_pw_policy_switch;
		uint32_t av_pw_hist_kvno;
		struct {
			u_int av_pw_hist_len;
			kdbe_pw_hist_t *av_pw_hist_val;
		} av_pw_hist;
		struct {
			u_int av_extension_len;
			char *av_extension_val;
		} av_extension;
	} kdbe_val_t_u;
};
typedef struct kdbe_val_t kdbe_val_t;

typedef struct {
	u_int kdbe_t_len;
	kdbe_val_t *kdbe_t_val;
} kdbe_t;

struct kdb_incr_update_t {
	utf8str_t kdb_princ_name;
	kdb_sno_t kdb_entry_sno;
	kdbe_time_t kdb_time;
	kdbe_t kdb_update;
	bool_t kdb_deleted;
	bool_t kdb_commit;
	struct {
		u_int kdb_kdcs_seen_by_len;
		utf8str_t *kdb_kdcs_seen_by_val;
	} kdb_kdcs_seen_by;
	struct {
		u_int kdb_futures_len;
		char *kdb_futures_val;
	} kdb_futures;
};
typedef struct kdb_incr_update_t kdb_incr_update_t;

typedef struct {
	u_int kdb_ulog_t_len;
	kdb_incr_update_t *kdb_ulog_t_val;
} kdb_ulog_t;

enum update_status_t {
	UPDATE_OK = 0,
	UPDATE_ERROR = 1,
	UPDATE_FULL_RESYNC_NEEDED = 2,
	UPDATE_BUSY = 3,
	UPDATE_NIL = 4,
	UPDATE_PERM_DENIED = 5
};
typedef enum update_status_t update_status_t;

struct kdb_last_t {
	kdb_sno_t last_sno;
	kdbe_time_t last_time;
};
typedef struct kdb_last_t kdb_last_t;

struct kdb_incr_result_t {
	kdb_last_t lastentry;
	kdb_ulog_t updates;
	update_status_t ret;
};
typedef struct kdb_incr_result_t kdb_incr_result_t;

struct kdb_fullresync_result_t {
	kdb_last_t lastentry;
	update_status_t ret;
};
typedef struct kdb_fullresync_result_t kdb_fullresync_result_t;

#define	KRB5_IPROP_PROG	100423
#define	KRB5_IPROP_VERS	1
#define	IPROP_NULL	0
extern  void * iprop_null_1();
#define	IPROP_GET_UPDATES	1
extern  kdb_incr_result_t * iprop_get_updates_1();
#define	IPROP_FULL_RESYNC	2
extern  kdb_fullresync_result_t * iprop_full_resync_1();
extern int krb5_iprop_prog_1_freeresult();

/* the xdr functions */
extern bool_t xdr_utf8str_t();
extern bool_t xdr_kdb_sno_t();
extern bool_t xdr_kdbe_time_t();
extern bool_t xdr_kdbe_key_t();
extern bool_t xdr_kdbe_data_t();
extern bool_t xdr_kdbe_princ_t();
extern bool_t xdr_kdbe_tl_t();
extern bool_t xdr_kdbe_pw_hist_t();
extern bool_t xdr_kdbe_attr_type_t();
extern bool_t xdr_kdbe_val_t();
extern bool_t xdr_kdbe_t();
extern bool_t xdr_kdb_incr_update_t();
extern bool_t xdr_kdb_ulog_t();
extern bool_t xdr_update_status_t();
extern bool_t xdr_kdb_last_t();
extern bool_t xdr_kdb_incr_result_t();
extern bool_t xdr_kdb_fullresync_result_t();

#endif /* !_IPROP_H_RPCGEN */
/*
 * Please do not edit this file.
 * It was generated using rpcgen.
 */

#include "iprop.h"

#ifndef _KERNEL
#include <stdlib.h>
#endif /* !_KERNEL */

#include "iprop.h"

bool_t
xdr_int16_t(xdrs, objp)
	XDR *xdrs;
	int16_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_short(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_uint16_t(xdrs, objp)
	XDR *xdrs;
	uint16_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_u_short(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_int32_t(xdrs, objp)
	XDR *xdrs;
	int32_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_int(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_uint32_t(xdrs, objp)
	XDR *xdrs;
	uint32_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_u_int(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_int64_t(xdrs, objp)
	XDR *xdrs;
	int64_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_longlong_t(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_uint64_t(xdrs, objp)
	XDR *xdrs;
	uint64_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_u_longlong_t(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_utf8str_t(xdrs, objp)
	XDR *xdrs;
	utf8str_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_bytes(xdrs, (char **)&objp->utf8str_t_val, (u_int *) &objp->utf8str_t_len, ~0))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_sno_t(xdrs, objp)
	XDR *xdrs;
	kdb_sno_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_uint32_t(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_time_t(xdrs, objp)
	XDR *xdrs;
	kdbe_time_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_uint32_t(xdrs, &objp->seconds))
		return (FALSE);
	if (!xdr_uint32_t(xdrs, &objp->useconds))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_key_t(xdrs, objp)
	XDR *xdrs;
	kdbe_key_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_int32_t(xdrs, &objp->k_ver))
		return (FALSE);
	if (!xdr_int32_t(xdrs, &objp->k_kvno))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->k_enctype.k_enctype_val, (u_int *) &objp->k_enctype.k_enctype_len, ~0,
		sizeof (int32_t), (xdrproc_t)xdr_int32_t))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->k_contents.k_contents_val, (u_int *) &objp->k_contents.k_contents_len, ~0,
		sizeof (utf8str_t), (xdrproc_t)xdr_utf8str_t))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_data_t(xdrs, objp)
	XDR *xdrs;
	kdbe_data_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_int32_t(xdrs, &objp->k_magic))
		return (FALSE);
	if (!xdr_utf8str_t(xdrs, &objp->k_data))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_princ_t(xdrs, objp)
	XDR *xdrs;
	kdbe_princ_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_utf8str_t(xdrs, &objp->k_realm))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->k_components.k_components_val, (u_int *) &objp->k_components.k_components_len, ~0,
		sizeof (kdbe_data_t), (xdrproc_t)xdr_kdbe_data_t))
		return (FALSE);
	if (!xdr_int32_t(xdrs, &objp->k_nametype))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_tl_t(xdrs, objp)
	XDR *xdrs;
	kdbe_tl_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_int16_t(xdrs, &objp->tl_type))
		return (FALSE);
	if (!xdr_bytes(xdrs, (char **)&objp->tl_data.tl_data_val, (u_int *) &objp->tl_data.tl_data_len, ~0))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_pw_hist_t(xdrs, objp)
	XDR *xdrs;
	kdbe_pw_hist_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_array(xdrs, (char **)&objp->kdbe_pw_hist_t_val, (u_int *) &objp->kdbe_pw_hist_t_len, ~0,
		sizeof (kdbe_key_t), (xdrproc_t)xdr_kdbe_key_t))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_attr_type_t(xdrs, objp)
	XDR *xdrs;
	kdbe_attr_type_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_enum(xdrs, (enum_t *)objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdbe_val_t(xdrs, objp)
	XDR *xdrs;
	kdbe_val_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_kdbe_attr_type_t(xdrs, &objp->av_type))
		return (FALSE);
	switch (objp->av_type) {
	case AT_ATTRFLAGS:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_attrflags))
			return (FALSE);
		break;
	case AT_MAX_LIFE:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_max_life))
			return (FALSE);
		break;
	case AT_MAX_RENEW_LIFE:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_max_renew_life))
			return (FALSE);
		break;
	case AT_EXP:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_exp))
			return (FALSE);
		break;
	case AT_PW_EXP:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_pw_exp))
			return (FALSE);
		break;
	case AT_LAST_SUCCESS:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_last_success))
			return (FALSE);
		break;
	case AT_LAST_FAILED:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_last_failed))
			return (FALSE);
		break;
	case AT_FAIL_AUTH_COUNT:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_fail_auth_count))
			return (FALSE);
		break;
	case AT_PRINC:
		if (!xdr_kdbe_princ_t(xdrs, &objp->kdbe_val_t_u.av_princ))
			return (FALSE);
		break;
	case AT_KEYDATA:
		if (!xdr_array(xdrs, (char **)&objp->kdbe_val_t_u.av_keydata.av_keydata_val, (u_int *) &objp->kdbe_val_t_u.av_keydata.av_keydata_len, ~0,
			sizeof (kdbe_key_t), (xdrproc_t)xdr_kdbe_key_t))
			return (FALSE);
		break;
	case AT_TL_DATA:
		if (!xdr_array(xdrs, (char **)&objp->kdbe_val_t_u.av_tldata.av_tldata_val, (u_int *) &objp->kdbe_val_t_u.av_tldata.av_tldata_len, ~0,
			sizeof (kdbe_tl_t), (xdrproc_t)xdr_kdbe_tl_t))
			return (FALSE);
		break;
	case AT_LEN:
		if (!xdr_int16_t(xdrs, &objp->kdbe_val_t_u.av_len))
			return (FALSE);
		break;
	case AT_PW_LAST_CHANGE:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_pw_last_change))
			return (FALSE);
		break;
	case AT_MOD_PRINC:
		if (!xdr_kdbe_princ_t(xdrs, &objp->kdbe_val_t_u.av_mod_princ))
			return (FALSE);
		break;
	case AT_MOD_TIME:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_mod_time))
			return (FALSE);
		break;
	case AT_MOD_WHERE:
		if (!xdr_utf8str_t(xdrs, &objp->kdbe_val_t_u.av_mod_where))
			return (FALSE);
		break;
	case AT_PW_POLICY:
		if (!xdr_utf8str_t(xdrs, &objp->kdbe_val_t_u.av_pw_policy))
			return (FALSE);
		break;
	case AT_PW_POLICY_SWITCH:
		if (!xdr_bool(xdrs, &objp->kdbe_val_t_u.av_pw_policy_switch))
			return (FALSE);
		break;
	case AT_PW_HIST_KVNO:
		if (!xdr_uint32_t(xdrs, &objp->kdbe_val_t_u.av_pw_hist_kvno))
			return (FALSE);
		break;
	case AT_PW_HIST:
		if (!xdr_array(xdrs, (char **)&objp->kdbe_val_t_u.av_pw_hist.av_pw_hist_val, (u_int *) &objp->kdbe_val_t_u.av_pw_hist.av_pw_hist_len, ~0,
			sizeof (kdbe_pw_hist_t), (xdrproc_t)xdr_kdbe_pw_hist_t))
			return (FALSE);
		break;
	default:
		if (!xdr_bytes(xdrs, (char **)&objp->kdbe_val_t_u.av_extension.av_extension_val, (u_int *) &objp->kdbe_val_t_u.av_extension.av_extension_len, ~0))
			return (FALSE);
		break;
	}
	return (TRUE);
}

bool_t
xdr_kdbe_t(xdrs, objp)
	XDR *xdrs;
	kdbe_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_array(xdrs, (char **)&objp->kdbe_t_val, (u_int *) &objp->kdbe_t_len, ~0,
		sizeof (kdbe_val_t), (xdrproc_t)xdr_kdbe_val_t))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_incr_update_t(xdrs, objp)
	XDR *xdrs;
	kdb_incr_update_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_utf8str_t(xdrs, &objp->kdb_princ_name))
		return (FALSE);
	if (!xdr_kdb_sno_t(xdrs, &objp->kdb_entry_sno))
		return (FALSE);
	if (!xdr_kdbe_time_t(xdrs, &objp->kdb_time))
		return (FALSE);
	if (!xdr_kdbe_t(xdrs, &objp->kdb_update))
		return (FALSE);
	if (!xdr_bool(xdrs, &objp->kdb_deleted))
		return (FALSE);
	if (!xdr_bool(xdrs, &objp->kdb_commit))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->kdb_kdcs_seen_by.kdb_kdcs_seen_by_val, (u_int *) &objp->kdb_kdcs_seen_by.kdb_kdcs_seen_by_len, ~0,
		sizeof (utf8str_t), (xdrproc_t)xdr_utf8str_t))
		return (FALSE);
	if (!xdr_bytes(xdrs, (char **)&objp->kdb_futures.kdb_futures_val, (u_int *) &objp->kdb_futures.kdb_futures_len, ~0))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_ulog_t(xdrs, objp)
	XDR *xdrs;
	kdb_ulog_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_array(xdrs, (char **)&objp->kdb_ulog_t_val, (u_int *) &objp->kdb_ulog_t_len, ~0,
		sizeof (kdb_incr_update_t), (xdrproc_t)xdr_kdb_incr_update_t))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_update_status_t(xdrs, objp)
	XDR *xdrs;
	update_status_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_enum(xdrs, (enum_t *)objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_last_t(xdrs, objp)
	XDR *xdrs;
	kdb_last_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_kdb_sno_t(xdrs, &objp->last_sno))
		return (FALSE);
	if (!xdr_kdbe_time_t(xdrs, &objp->last_time))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_incr_result_t(xdrs, objp)
	XDR *xdrs;
	kdb_incr_result_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_kdb_last_t(xdrs, &objp->lastentry))
		return (FALSE);
	if (!xdr_kdb_ulog_t(xdrs, &objp->updates))
		return (FALSE);
	if (!xdr_update_status_t(xdrs, &objp->ret))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_kdb_fullresync_result_t(xdrs, objp)
	XDR *xdrs;
	kdb_fullresync_result_t *objp;
{

	rpc_inline_t *buf __unused;

	if (!xdr_kdb_last_t(xdrs, &objp->lastentry))
		return (FALSE);
	if (!xdr_update_status_t(xdrs, &objp->ret))
		return (FALSE);
	return (TRUE);
}
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This module will parse the update logs on the master or slave servers.
 */

#include <stdio.h>
#include <libintl.h>
#include <sys/types.h>
#include <time.h>
#include <limits.h>
#include <locale.h>
#include <syslog.h>
#include <kdb/kdb_log.h>
#include <kadm5/admin.h>

static char	*progname;

static void
usage()
{
	(void) fprintf(stderr, gettext("\nUsage: %s [-h] [-v] [-e num]\n\n"),
	    progname);
	exit(1);
}

/*
 * Print the individual types if verbose mode was specified.
 */
static void
print_attr(kdbe_attr_type_t type)
{
	switch (type) {
		case AT_ATTRFLAGS:
			(void) printf(gettext("\t\tAttribute flags\n"));
			break;
		case AT_MAX_LIFE:
			(void) printf(gettext("\t\tMaximum ticket life\n"));
			break;
		case AT_MAX_RENEW_LIFE:
			(void) printf(gettext("\t\tMaximum renewable life\n"));
			break;
		case AT_EXP:
			(void) printf(gettext("\t\tPrincipal expiration\n"));
			break;
		case AT_PW_EXP:
			(void) printf(gettext("\t\tPassword expiration\n"));
			break;
		case AT_LAST_SUCCESS:
			(void) printf(gettext("\t\tLast successful auth\n"));
			break;
		case AT_LAST_FAILED:
			(void) printf(gettext("\t\tLast failed auth\n"));
			break;
		case AT_FAIL_AUTH_COUNT:
			(void) printf(gettext("\t\tFailed passwd attempt\n"));
			break;
		case AT_PRINC:
			(void) printf(gettext("\t\tPrincipal\n"));
			break;
		case AT_KEYDATA:
			(void) printf(gettext("\t\tKey data\n"));
			break;
		case AT_TL_DATA:
			(void) printf(gettext("\t\tTL data\n"));
			break;
		case AT_LEN:
			(void) printf(gettext("\t\tLength\n"));
			break;
		case AT_MOD_PRINC:
			(void) printf(gettext("\t\tModifying principal\n"));
			break;
		case AT_MOD_TIME:
			(void) printf(gettext("\t\tModification time\n"));
			break;
		case AT_MOD_WHERE:
			(void) printf(gettext("\t\tModified where\n"));
			break;
		case AT_PW_LAST_CHANGE:
			(void) printf(gettext("\t\tPassword last changed\n"));
			break;
		case AT_PW_POLICY:
			(void) printf(gettext("\t\tPassword policy\n"));
			break;
		case AT_PW_POLICY_SWITCH:
			(void) printf(gettext("\t\tPassword policy switch\n"));
			break;
		case AT_PW_HIST_KVNO:
			(void) printf(gettext("\t\tPassword history KVNO\n"));
			break;
		case AT_PW_HIST:
			(void) printf(gettext("\t\tPassword history\n"));
			break;
	} /* switch */

}
/*
 * Print the update entry information
 */
static void
print_update(kdb_hlog_t *ulog, uint32_t entry, bool_t verbose)
{
	XDR		xdrs;
	uint32_t	start_sno, i, j, indx;
	char		*dbprinc;
	kdb_ent_header_t *indx_log;
	kdb_incr_update_t upd;

	if (entry && (entry < ulog->kdb_num))
		start_sno = ulog->kdb_last_sno - entry;
	else
		start_sno = ulog->kdb_first_sno - 1;

	for (i = start_sno; i < ulog->kdb_last_sno; i++) {
		indx = i % ulog->kdb_num;

		indx_log = (kdb_ent_header_t *)INDEX(ulog, indx);

		/*
		 * Check for corrupt update entry
		 */
		if (indx_log->kdb_umagic != KDB_UMAGIC) {
			(void) fprintf(stderr,
			    gettext("Corrupt update entry\n\n"));
			exit(1);
		}

		(void) memset((char *)&upd, 0, sizeof (kdb_incr_update_t));
		xdrmem_create(&xdrs, (char *)indx_log->entry_data,
		    indx_log->kdb_entry_size, XDR_DECODE);
		if (!xdr_kdb_incr_update_t(&xdrs, &upd)) {
			(void) printf(gettext("Entry data decode failure\n\n"));
			exit(1);
		}

		(void) printf("---\n");
		(void) printf(gettext("Update Entry\n"));

		(void) printf(gettext("\tUpdate serial # : %u\n"),
		    indx_log->kdb_entry_sno);

		(void) printf(gettext("\tUpdate operation : "));
		if (upd.kdb_deleted)
			(void) printf(gettext("Delete\n"));
		else
			(void) printf(gettext("Add\n"));

		dbprinc = malloc(upd.kdb_princ_name.utf8str_t_len + 1);
		if (dbprinc == NULL) {
			(void) printf(gettext("Could not allocate "
			    "principal name\n\n"));
			exit(1);
		}
		(void) strlcpy(dbprinc, upd.kdb_princ_name.utf8str_t_val,
		    (upd.kdb_princ_name.utf8str_t_len + 1));
		(void) printf(gettext("\tUpdate principal : %s\n"), dbprinc);

		(void) printf(gettext("\tUpdate size : %u\n"),
		    indx_log->kdb_entry_size);

		(void) printf(gettext("\tUpdate committed : %s\n"),
		    indx_log->kdb_commit ? "True" : "False");

		if (indx_log->kdb_time.seconds == 0L)
			(void) printf(gettext("\tUpdate time stamp : None\n"));
		else
			(void) printf(gettext("\tUpdate time stamp : %s"),
			    ctime((time_t *)&(indx_log->kdb_time.seconds)));

		(void) printf(gettext("\tAttributes changed : %d\n"),
		    upd.kdb_update.kdbe_t_len);

		if (verbose)
			for (j = 0; j < upd.kdb_update.kdbe_t_len; j++)
				print_attr(
				    upd.kdb_update.kdbe_t_val[j].av_type);

		xdr_free(xdr_kdb_incr_update_t, (char *)&upd);
		if (dbprinc)
			free(dbprinc);
	} /* for */
}

int
main(int argc, char **argv)
{
	int			c;
	bool_t			verbose = FALSE;
	bool_t			headeronly = FALSE;
	uint32_t		entry = 0;
	krb5_context		context;
	kadm5_config_params	params;
	kdb_log_context		*log_ctx;
	kdb_hlog_t		*ulog = NULL;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif /* TEXT_DOMAIN */

	(void) textdomain(TEXT_DOMAIN);

	if (geteuid() != (uid_t)0) {
		(void) fprintf(stderr,
		    gettext("kproplog must be run as root\n\n"));
		exit(1);
	}

	progname = argv[0];

	while ((c = getopt(argc, argv, "vhe:")) != -1) {
		switch (c) {
			case 'h':
				headeronly = TRUE;
				break;
			case 'e':
				entry = atoi(optarg);
				break;
			case 'v':
				verbose = TRUE;
				break;
			default:
				usage();
		}
	}

	if (krb5_init_context(&context)) {
		(void) fprintf(stderr,
		    gettext("Unable to initialize Kerberos\n\n"));
		exit(1);
	}

	(void) memset((char *)&params, 0, sizeof (params));

	if (kadm5_get_config_params(context, NULL, NULL, &params, &params)) {
		(void) fprintf(stderr,
		    gettext("Couldn't read database_name\n\n"));
		exit(1);
	}

	(void) printf(gettext("\nKerberos update log (%s.ulog)\n"),
	    params.dbname);

	if (ulog_map(context, &params, FKPROPLOG)) {
		(void) fprintf(stderr, gettext("Unable to map log file "
		    "%s.ulog\n\n"), params.dbname);
		exit(1);
	}

	log_ctx = context->kdblog_context;
	if (log_ctx)
		ulog = log_ctx->ulog;
	else {
		(void) fprintf(stderr, gettext("Unable to map log file "
		    "%s.ulog\n\n"), params.dbname);
		exit(1);
	}

	if (ulog->kdb_hmagic != KDB_HMAGIC) {
		(void) fprintf(stderr,
		    gettext("Corrupt header log, exiting\n\n"));
		exit(1);
	}

	(void) printf(gettext("Update log dump :\n"));
	(void) printf(gettext("\tLog version # : %u\n"), ulog->db_version_num);
	(void) printf(gettext("\tLog state : "));
	switch (ulog->kdb_state) {
		case KDB_STABLE:
			(void) printf(gettext("Stable\n"));
			break;
		case KDB_UNSTABLE:
			(void) printf(gettext("Unstable\n"));
			break;
		case KDB_CORRUPT:
			(void) printf(gettext("Corrupt\n"));
			break;
		default:
			(void) printf(gettext("Unknown state: %d\n"),
			    ulog->kdb_state);
			break;
	}
	(void) printf(gettext("\tEntry block size : %u\n"), ulog->kdb_block);
	(void) printf(gettext("\tNumber of entries : %u\n"), ulog->kdb_num);

	if (ulog->kdb_last_sno == 0)
		(void) printf(gettext("\tLast serial # : None\n"));
	else {
		if (ulog->kdb_first_sno == 0)
			(void) printf(gettext("\tFirst serial # : None\n"));
		else {
			(void) printf(gettext("\tFirst serial # : "));
			(void) printf("%u\n", ulog->kdb_first_sno);
		}

		(void) printf(gettext("\tLast serial # : "));
		(void) printf("%u\n", ulog->kdb_last_sno);
	}

	if (ulog->kdb_last_time.seconds == 0L) {
		(void) printf(gettext("\tLast time stamp : None\n"));
	} else {
		if (ulog->kdb_first_time.seconds == 0L)
			(void) printf(gettext("\tFirst time stamp : None\n"));
		else {
			(void) printf(gettext("\tFirst time stamp : %s"),
			    ctime((time_t *)
			    &(ulog->kdb_first_time.seconds)));
		}

		(void) printf(gettext("\tLast time stamp : %s\n"),
		    ctime((time_t *)&(ulog->kdb_last_time.seconds)));
	}

	if ((!headeronly) && ulog->kdb_num) {
		print_update(ulog, entry, verbose);
	}

	(void) printf("\n");

	return (0);
}