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

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

#include "ldap_util.h"
#include "ldap_print.h"


void
printMappingFormat(__nis_mapping_format_t *f) {
	__nis_value_t	*val = getMappingFormat(f, 0, fa_any, 0, 0);
	int		i;
	char		*myself = "printMappingFormat";

	if (val == 0)
		return;

	for (i = 0; i < val->numVals; i++) {
		c2buf(myself, val->val[i].value, val->val[i].length);
	}
	freeValue(val, 1);
}

void
printMappingFormatArray(__nis_mapping_format_t *a) {
	__nis_value_t	*val = getMappingFormatArray(a, 0, fa_any, 0, 0);
	char		*myself = "printMappingFormatArray";

	if (val != 0) {
		if (val->type == vt_string) {
			int	i;

			if (a[0].type != mmt_begin)
				p2buf(myself, "\"");
			for (i = 0; i < val->numVals; i++) {
				sc2buf(myself, val->val[i].value,
					val->val[i].length);
			}
		} else {
			p2buf(myself, "<illegal>");
		}
		freeValue(val, 1);
	} else {
		p2buf(myself, "<novals>");
	}
}

void
printIndex(__nis_index_t *i) {
	int	len = 0;
	char	*str = getIndex(i, &len);
	char	*myself = "printIndex";

	sc2buf(myself, str, len);
	sfree(str);
}

void
printObjSpec(__nis_obj_spec_t *o) {
	int	len = 0;
	char	*str = getObjSpec(o, &len);
	char	*myself = "printObjSpec";

	sc2buf(myself, str, len);
	sfree(str);
}

void
printSearchTriple(__nis_search_triple_t *s) {
	int	len = 0;
	char	*str = getSearchTriple(s, &len);
	char	*myself = "printSearchTriple";

	sc2buf(myself, str, len);
	sfree(str);
}

void
printMappingItem(__nis_mapping_item_t *i, __nis_mapping_item_type_t native) {
	__nis_value_t	*val = getMappingItem(i, native, 0, 0, NULL);
	int		j;
	char		*myself = "printMappingItem";

	if (val == 0)
		return;

	if (i->repeat)
		p2buf(myself, "(");
	for (j = 0; j < val->numVals; j++) {
		c2buf(myself, val->val[j].value, val->val[j].length);
	}
	if (i->repeat)
		p2buf(myself, ")");
	freeValue(val, 1);
}

void
printMappingSubElement(__nis_mapping_sub_element_t *e,
			__nis_mapping_item_type_t native) {
	int	i;
	char	*myself = "printMappingSubElement";

	switch (e->type) {
	case me_item:
		printMappingItem(&e->element.item, native);
		break;
	case me_print:
		p2buf(myself, "(");
		printMappingFormatArray(e->element.print.fmt);
		for (i = 0; i < e->element.print.numItems; i++) {
			p2buf(myself, ", ");
			printMappingItem(&e->element.print.item[i], native);
		}
		if (e->element.print.doElide) {
			p2buf(myself, ", \"%c\"", e->element.print.elide);
		}
		p2buf(myself, ")");
		break;
	case me_split:
		p2buf(myself, "(");
		printMappingItem(&e->element.split.item, native);
		p2buf(myself, ", \"%c\")", e->element.split.delim);
		break;
	case me_match:
		p2buf(myself, "<me_match>");
		break;
	case me_extract:
		p2buf(myself, "(");
		printMappingItem(&e->element.extract.item, native);
		p2buf(myself, ", ");
		printMappingFormatArray(e->element.extract.fmt);
		p2buf(myself, ")");
		break;
	default:
		p2buf(myself, "(<unknown>)");
		break;
	}
}

void
printMappingElement(__nis_mapping_element_t *e,
			__nis_mapping_item_type_t native) {
	int	i;
	char	*myself = "printMappingElement";

	switch (e->type) {
	case me_item:
		printMappingItem(&e->element.item, native);
		break;
	case me_print:
		p2buf(myself, "(");
		printMappingFormatArray(e->element.print.fmt);
		for (i = 0; i < e->element.print.numSubElements; i++) {
			p2buf(myself, ", ");
			printMappingSubElement(
				&e->element.print.subElement[i], native);
		}
		if (e->element.print.doElide) {
			p2buf(myself, ", \"%c\"", e->element.print.elide);
		}
		p2buf(myself, ")");
		break;
	case me_split:
		p2buf(myself, "(");
		printMappingItem(&e->element.split.item, native);
		p2buf(myself, ", \"%c\")", e->element.split.delim);
		break;
	case me_match:
		p2buf(myself, "(");
		printMappingFormatArray(e->element.match.fmt);
		for (i = 0; i < e->element.match.numItems; i++) {
			p2buf(myself, ", ");
			printMappingItem(&e->element.match.item[i], native);
		}
		p2buf(myself, ")");
		break;
	case me_extract:
		p2buf(myself, "(");
		printMappingItem(&e->element.extract.item, native);
		p2buf(myself, ", ");
		printMappingFormatArray(e->element.extract.fmt);
		p2buf(myself, ")");
		break;
	default:
		p2buf(myself, "(<unknown>)");
		break;
	}
}

void
printMappingRLHS(__nis_mapping_rlhs_t *m, __nis_mapping_item_type_t native) {
	int	i;
	char	*myself = "printMappingRLHS";

	if (m->numElements > 1)
		p2buf(myself, "(");
	for (i = 0; i < m->numElements; i++) {
		printMappingElement(&m->element[i], native);
	}
	if (m->numElements > 1)
		p2buf(myself, ")");
}

void
printMappingRule(__nis_mapping_rule_t *r,
		__nis_mapping_item_type_t nativeLhs,
		__nis_mapping_item_type_t nativeRhs) {
	char		*myself = "printMappingRule";

	printMappingRLHS(&r->lhs, nativeLhs);
	p2buf(myself, "=");
	printMappingRLHS(&r->rhs, nativeRhs);
}

void
printObjName(__nis_index_t *index, char *name) {
	char		*myself = "printObjName";

	printIndex(index);
	p2buf(myself, "%s", NIL(name));
}

void
printobjectDN(__nis_object_dn_t *o) {
	char		*myself = "printobjectDN";
	int		i;

	p2buf(myself, "\t");
	printSearchTriple(&o->read);
	p2buf(myself, ":\n\t");
	printSearchTriple(&o->write);
	switch (o->delDisp) {
	case dd_always:
		p2buf(myself, ":\n\t\talways");
		break;
	case dd_perDbId:
		p2buf(myself, ":\n\t\tdbid=%s\n", NIL(o->dbIdName));
		for (i = 0; i < o->numDbIds; i++) {
			p2buf(myself, "\t\t\t");
			printMappingRule(o->dbId[i], mit_ldap, mit_nisplus);
		}
		break;
	case dd_never:
		p2buf(myself, ":\n\t\tnever");
		break;
	default:
		p2buf(myself, ":\n\t\t<unknown>");
	}
}

void
printTableMapping(__nis_table_mapping_t *t) {
	__nis_object_dn_t	*o;
	int			i;
	char			*myself = "printTableMapping";

	p2buf(myself, "\n%s:", NIL(t->dbId));
	printObjName(&t->index, t->objName);
	p2buf(myself, "\n\t%s \t%s", NIL(t->objName), NIL(t->objPath));
	p2buf(myself, "\n\tTTL = (%d - %d) -> %d\n",
		t->initTtlLo, t->initTtlHi, t->ttl);

	for (o = t->objectDN; o != 0; o = o->next) {
		printobjectDN(o);
		p2buf(myself, "\n");
	}

	p2buf(myself, "\tLDAP -> NIS+\n");
	p2buf(myself, "\tRules:\n");
	for (i = 0; i < t->numRulesFromLDAP; i++) {
		p2buf(myself, "\t\t");
		printMappingRule(t->ruleFromLDAP[i], mit_nisplus, mit_ldap);
		p2buf(myself, "\n");
	}

	p2buf(myself, "\tNIS+ -> LDAP\n");
	p2buf(myself, "\tRules:\n");
	for (i = 0; i < t->numRulesToLDAP; i++) {
		p2buf(myself, "\t\t");
		printMappingRule(t->ruleToLDAP[i], mit_ldap, mit_nisplus);
		p2buf(myself, "\n");
	}
}

void
printRuleValue(__nis_rule_value_t *rv) {
	int		i, j;
	__nis_buffer_t	b = {0, 0};
	char		*myself = "printRuleValue";

	if (rv == 0)
		return;

	if (rv->colName != 0) {
		bp2buf(myself, &b, "Columns:\n");
		for (i = 0; i < rv->numColumns; i++) {
			bp2buf(myself, &b, "\t%s", NIL(rv->colName[i]));
			if (rv->colVal[i].numVals == 1) {
				bp2buf(myself, &b, "=");
				if (rv->colVal[i].type == vt_string)
					sbc2buf(myself,
						rv->colVal[i].val[0].value,
					rv->colVal[i].val[0].length, &b);
				else
					bc2buf(myself,
						rv->colVal[i].val[0].value,
					rv->colVal[i].val[0].length, &b);
				bp2buf(myself, &b, "\n");
			} else {
				bp2buf(myself, &b, "\n");
				for (j = 0; j < rv->colVal[i].numVals; j++) {
					bp2buf(myself, &b, "\t\t");
					if (rv->colVal[i].type == vt_string)
						sbc2buf(myself,
						rv->colVal[i].val[j].value,
						rv->colVal[i].val[j].length,
						&b);
					else
						bc2buf(myself,
						rv->colVal[i].val[j].value,
						rv->colVal[i].val[j].length,
						&b);
					bp2buf(myself, &b, "\n");
				}
			}
		}
	}

	if (rv->attrName != 0) {
		bp2buf(myself, &b, "Attributes:\n");
		for (i = 0; i < rv->numAttrs; i++) {
			bp2buf(myself, &b, "\t%s", NIL(rv->attrName[i]));
			if (rv->attrVal[i].numVals == 1) {
				bp2buf(myself, &b, "=");
				if (rv->attrVal[i].type == vt_string)
					sbc2buf(myself,
						rv->attrVal[i].val[0].value,
						rv->attrVal[i].val[0].length,
						&b);
				else
					bc2buf(myself,
						rv->attrVal[i].val[0].value,
						rv->attrVal[i].val[0].length,
						&b);
				bp2buf(myself, &b, "\n");
			} else {
				bp2buf(myself, &b, "\n");
				for (j = 0; j < rv->attrVal[i].numVals; j++) {
					bp2buf(myself, &b, "\t\t");
					if (rv->attrVal[i].type == vt_string)
						sbc2buf(myself,
						rv->attrVal[i].val[j].value,
						rv->attrVal[i].val[j].length,
						&b);
					else
						bc2buf(myself,
						rv->attrVal[i].val[j].value,
						rv->attrVal[i].val[j].length,
						&b);
					bp2buf(myself, &b, "\n");
				}
			}
		}
	}

	c2buf(myself, b.buf, b.len);
	sfree(b.buf);
	printbuf();
}

void
printLdapMod(LDAPMod **mods, __nis_buffer_t *b) {
	LDAPMod		*m;
	char		*s;
	char		*myself = "printLdapMod";

	if (mods == 0)
		return;

	if (b == 0)
		b = &pb;

	while ((m = *mods) != 0) {
		if ((m->mod_op & LDAP_MOD_ADD) != 0 ||
				(m->mod_op & ~LDAP_MOD_BVALUES) == 0) {
			s = "ADD    ";
		} else if ((m->mod_op & LDAP_MOD_DELETE) != 0) {
			s = "DELETE ";
		} else if ((m->mod_op & LDAP_MOD_REPLACE) != 0) {
			s = "REPLACE";
		} else {
			s = "UNKNOWN";
		}
		bp2buf(myself, b, "%s: %s\n", s, m->mod_type);
		if ((m->mod_op & LDAP_MOD_BVALUES) == 0) {
			char	**v = m->mod_values;

			if (v != 0) {
				while (*v != 0) {
					bp2buf(myself, b, "\t%s\n", *v);
					v++;
				}
			}
		} else {
			struct berval	**bv = m->mod_bvalues;

			if (bv != 0) {
				while (*bv != 0) {
					bp2buf(myself, b, "\t<ber> %d bytes\n",
						(*bv)->bv_len);
					bv++;
				}
			}
		}
		mods++;
	}
}

static void
printObjRights(char *msg, void *access) {
	uchar_t	*a = access;
	int	i;

	if (a == 0)
		return;

	for (i = 0; i < 4; i++) {
		p2buf(msg, "%s", (a[i] & NIS_READ_ACC) ? "r" : "-");
		p2buf(msg, "%s", (a[i] & NIS_MODIFY_ACC) ? "m" : "-");
		p2buf(msg, "%s", (a[i] & NIS_CREATE_ACC) ? "c" : "-");
		p2buf(msg, "%s", (a[i] & NIS_DESTROY_ACC) ? "d" : "-");
	}
}

void
printObjAttr(__nis_obj_attr_t *attr) {
	char	*myself = "printObjAttr";

	if (attr == 0)
		return;

	p2buf(myself, "\tzo_owner  = %s\n", NIL(attr->zo_owner));
	p2buf(myself, "\tzo_group  = %s\n", NIL(attr->zo_group));
	p2buf(myself, "\tzo_domain = %s\n", NIL(attr->zo_domain));
	p2buf(myself, "\tzo_access = ");
	printObjRights(myself, &attr->zo_access);
	p2buf(myself, " (0x%08x)\n", attr->zo_access);
	p2buf(myself, "\tzo_ttl    = %d\n", attr->zo_ttl);
}