xref: /illumos-gate/usr/src/lib/libnisdb/ldap_print.c (revision 1da57d55)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2001-2003 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include "ldap_util.h"
28 #include "ldap_print.h"
29 
30 
31 void
printMappingFormat(__nis_mapping_format_t * f)32 printMappingFormat(__nis_mapping_format_t *f) {
33 	__nis_value_t	*val = getMappingFormat(f, 0, fa_any, 0, 0);
34 	int		i;
35 	char		*myself = "printMappingFormat";
36 
37 	if (val == 0)
38 		return;
39 
40 	for (i = 0; i < val->numVals; i++) {
41 		c2buf(myself, val->val[i].value, val->val[i].length);
42 	}
43 	freeValue(val, 1);
44 }
45 
46 void
printMappingFormatArray(__nis_mapping_format_t * a)47 printMappingFormatArray(__nis_mapping_format_t *a) {
48 	__nis_value_t	*val = getMappingFormatArray(a, 0, fa_any, 0, 0);
49 	char		*myself = "printMappingFormatArray";
50 
51 	if (val != 0) {
52 		if (val->type == vt_string) {
53 			int	i;
54 
55 			if (a[0].type != mmt_begin)
56 				p2buf(myself, "\"");
57 			for (i = 0; i < val->numVals; i++) {
58 				sc2buf(myself, val->val[i].value,
59 					val->val[i].length);
60 			}
61 		} else {
62 			p2buf(myself, "<illegal>");
63 		}
64 		freeValue(val, 1);
65 	} else {
66 		p2buf(myself, "<novals>");
67 	}
68 }
69 
70 void
printIndex(__nis_index_t * i)71 printIndex(__nis_index_t *i) {
72 	int	len = 0;
73 	char	*str = getIndex(i, &len);
74 	char	*myself = "printIndex";
75 
76 	sc2buf(myself, str, len);
77 	sfree(str);
78 }
79 
80 void
printObjSpec(__nis_obj_spec_t * o)81 printObjSpec(__nis_obj_spec_t *o) {
82 	int	len = 0;
83 	char	*str = getObjSpec(o, &len);
84 	char	*myself = "printObjSpec";
85 
86 	sc2buf(myself, str, len);
87 	sfree(str);
88 }
89 
90 void
printSearchTriple(__nis_search_triple_t * s)91 printSearchTriple(__nis_search_triple_t *s) {
92 	int	len = 0;
93 	char	*str = getSearchTriple(s, &len);
94 	char	*myself = "printSearchTriple";
95 
96 	sc2buf(myself, str, len);
97 	sfree(str);
98 }
99 
100 void
printMappingItem(__nis_mapping_item_t * i,__nis_mapping_item_type_t native)101 printMappingItem(__nis_mapping_item_t *i, __nis_mapping_item_type_t native) {
102 	__nis_value_t	*val = getMappingItem(i, native, 0, 0, NULL);
103 	int		j;
104 	char		*myself = "printMappingItem";
105 
106 	if (val == 0)
107 		return;
108 
109 	if (i->repeat)
110 		p2buf(myself, "(");
111 	for (j = 0; j < val->numVals; j++) {
112 		c2buf(myself, val->val[j].value, val->val[j].length);
113 	}
114 	if (i->repeat)
115 		p2buf(myself, ")");
116 	freeValue(val, 1);
117 }
118 
119 void
printMappingSubElement(__nis_mapping_sub_element_t * e,__nis_mapping_item_type_t native)120 printMappingSubElement(__nis_mapping_sub_element_t *e,
121 			__nis_mapping_item_type_t native) {
122 	int	i;
123 	char	*myself = "printMappingSubElement";
124 
125 	switch (e->type) {
126 	case me_item:
127 		printMappingItem(&e->element.item, native);
128 		break;
129 	case me_print:
130 		p2buf(myself, "(");
131 		printMappingFormatArray(e->element.print.fmt);
132 		for (i = 0; i < e->element.print.numItems; i++) {
133 			p2buf(myself, ", ");
134 			printMappingItem(&e->element.print.item[i], native);
135 		}
136 		if (e->element.print.doElide) {
137 			p2buf(myself, ", \"%c\"", e->element.print.elide);
138 		}
139 		p2buf(myself, ")");
140 		break;
141 	case me_split:
142 		p2buf(myself, "(");
143 		printMappingItem(&e->element.split.item, native);
144 		p2buf(myself, ", \"%c\")", e->element.split.delim);
145 		break;
146 	case me_match:
147 		p2buf(myself, "<me_match>");
148 		break;
149 	case me_extract:
150 		p2buf(myself, "(");
151 		printMappingItem(&e->element.extract.item, native);
152 		p2buf(myself, ", ");
153 		printMappingFormatArray(e->element.extract.fmt);
154 		p2buf(myself, ")");
155 		break;
156 	default:
157 		p2buf(myself, "(<unknown>)");
158 		break;
159 	}
160 }
161 
162 void
printMappingElement(__nis_mapping_element_t * e,__nis_mapping_item_type_t native)163 printMappingElement(__nis_mapping_element_t *e,
164 			__nis_mapping_item_type_t native) {
165 	int	i;
166 	char	*myself = "printMappingElement";
167 
168 	switch (e->type) {
169 	case me_item:
170 		printMappingItem(&e->element.item, native);
171 		break;
172 	case me_print:
173 		p2buf(myself, "(");
174 		printMappingFormatArray(e->element.print.fmt);
175 		for (i = 0; i < e->element.print.numSubElements; i++) {
176 			p2buf(myself, ", ");
177 			printMappingSubElement(
178 				&e->element.print.subElement[i], native);
179 		}
180 		if (e->element.print.doElide) {
181 			p2buf(myself, ", \"%c\"", e->element.print.elide);
182 		}
183 		p2buf(myself, ")");
184 		break;
185 	case me_split:
186 		p2buf(myself, "(");
187 		printMappingItem(&e->element.split.item, native);
188 		p2buf(myself, ", \"%c\")", e->element.split.delim);
189 		break;
190 	case me_match:
191 		p2buf(myself, "(");
192 		printMappingFormatArray(e->element.match.fmt);
193 		for (i = 0; i < e->element.match.numItems; i++) {
194 			p2buf(myself, ", ");
195 			printMappingItem(&e->element.match.item[i], native);
196 		}
197 		p2buf(myself, ")");
198 		break;
199 	case me_extract:
200 		p2buf(myself, "(");
201 		printMappingItem(&e->element.extract.item, native);
202 		p2buf(myself, ", ");
203 		printMappingFormatArray(e->element.extract.fmt);
204 		p2buf(myself, ")");
205 		break;
206 	default:
207 		p2buf(myself, "(<unknown>)");
208 		break;
209 	}
210 }
211 
212 void
printMappingRLHS(__nis_mapping_rlhs_t * m,__nis_mapping_item_type_t native)213 printMappingRLHS(__nis_mapping_rlhs_t *m, __nis_mapping_item_type_t native) {
214 	int	i;
215 	char	*myself = "printMappingRLHS";
216 
217 	if (m->numElements > 1)
218 		p2buf(myself, "(");
219 	for (i = 0; i < m->numElements; i++) {
220 		printMappingElement(&m->element[i], native);
221 	}
222 	if (m->numElements > 1)
223 		p2buf(myself, ")");
224 }
225 
226 void
printMappingRule(__nis_mapping_rule_t * r,__nis_mapping_item_type_t nativeLhs,__nis_mapping_item_type_t nativeRhs)227 printMappingRule(__nis_mapping_rule_t *r,
228 		__nis_mapping_item_type_t nativeLhs,
229 		__nis_mapping_item_type_t nativeRhs) {
230 	char		*myself = "printMappingRule";
231 
232 	printMappingRLHS(&r->lhs, nativeLhs);
233 	p2buf(myself, "=");
234 	printMappingRLHS(&r->rhs, nativeRhs);
235 }
236 
237 void
printObjName(__nis_index_t * index,char * name)238 printObjName(__nis_index_t *index, char *name) {
239 	char		*myself = "printObjName";
240 
241 	printIndex(index);
242 	p2buf(myself, "%s", NIL(name));
243 }
244 
245 void
printobjectDN(__nis_object_dn_t * o)246 printobjectDN(__nis_object_dn_t *o) {
247 	char		*myself = "printobjectDN";
248 	int		i;
249 
250 	p2buf(myself, "\t");
251 	printSearchTriple(&o->read);
252 	p2buf(myself, ":\n\t");
253 	printSearchTriple(&o->write);
254 	switch (o->delDisp) {
255 	case dd_always:
256 		p2buf(myself, ":\n\t\talways");
257 		break;
258 	case dd_perDbId:
259 		p2buf(myself, ":\n\t\tdbid=%s\n", NIL(o->dbIdName));
260 		for (i = 0; i < o->numDbIds; i++) {
261 			p2buf(myself, "\t\t\t");
262 			printMappingRule(o->dbId[i], mit_ldap, mit_nisplus);
263 		}
264 		break;
265 	case dd_never:
266 		p2buf(myself, ":\n\t\tnever");
267 		break;
268 	default:
269 		p2buf(myself, ":\n\t\t<unknown>");
270 	}
271 }
272 
273 void
printTableMapping(__nis_table_mapping_t * t)274 printTableMapping(__nis_table_mapping_t *t) {
275 	__nis_object_dn_t	*o;
276 	int			i;
277 	char			*myself = "printTableMapping";
278 
279 	p2buf(myself, "\n%s:", NIL(t->dbId));
280 	printObjName(&t->index, t->objName);
281 	p2buf(myself, "\n\t%s \t%s", NIL(t->objName), NIL(t->objPath));
282 	p2buf(myself, "\n\tTTL = (%d - %d) -> %d\n",
283 		t->initTtlLo, t->initTtlHi, t->ttl);
284 
285 	for (o = t->objectDN; o != 0; o = o->next) {
286 		printobjectDN(o);
287 		p2buf(myself, "\n");
288 	}
289 
290 	p2buf(myself, "\tLDAP -> NIS+\n");
291 	p2buf(myself, "\tRules:\n");
292 	for (i = 0; i < t->numRulesFromLDAP; i++) {
293 		p2buf(myself, "\t\t");
294 		printMappingRule(t->ruleFromLDAP[i], mit_nisplus, mit_ldap);
295 		p2buf(myself, "\n");
296 	}
297 
298 	p2buf(myself, "\tNIS+ -> LDAP\n");
299 	p2buf(myself, "\tRules:\n");
300 	for (i = 0; i < t->numRulesToLDAP; i++) {
301 		p2buf(myself, "\t\t");
302 		printMappingRule(t->ruleToLDAP[i], mit_ldap, mit_nisplus);
303 		p2buf(myself, "\n");
304 	}
305 }
306 
307 void
printRuleValue(__nis_rule_value_t * rv)308 printRuleValue(__nis_rule_value_t *rv) {
309 	int		i, j;
310 	__nis_buffer_t	b = {0, 0};
311 	char		*myself = "printRuleValue";
312 
313 	if (rv == 0)
314 		return;
315 
316 	if (rv->colName != 0) {
317 		bp2buf(myself, &b, "Columns:\n");
318 		for (i = 0; i < rv->numColumns; i++) {
319 			bp2buf(myself, &b, "\t%s", NIL(rv->colName[i]));
320 			if (rv->colVal[i].numVals == 1) {
321 				bp2buf(myself, &b, "=");
322 				if (rv->colVal[i].type == vt_string)
323 					sbc2buf(myself,
324 						rv->colVal[i].val[0].value,
325 					rv->colVal[i].val[0].length, &b);
326 				else
327 					bc2buf(myself,
328 						rv->colVal[i].val[0].value,
329 					rv->colVal[i].val[0].length, &b);
330 				bp2buf(myself, &b, "\n");
331 			} else {
332 				bp2buf(myself, &b, "\n");
333 				for (j = 0; j < rv->colVal[i].numVals; j++) {
334 					bp2buf(myself, &b, "\t\t");
335 					if (rv->colVal[i].type == vt_string)
336 						sbc2buf(myself,
337 						rv->colVal[i].val[j].value,
338 						rv->colVal[i].val[j].length,
339 						&b);
340 					else
341 						bc2buf(myself,
342 						rv->colVal[i].val[j].value,
343 						rv->colVal[i].val[j].length,
344 						&b);
345 					bp2buf(myself, &b, "\n");
346 				}
347 			}
348 		}
349 	}
350 
351 	if (rv->attrName != 0) {
352 		bp2buf(myself, &b, "Attributes:\n");
353 		for (i = 0; i < rv->numAttrs; i++) {
354 			bp2buf(myself, &b, "\t%s", NIL(rv->attrName[i]));
355 			if (rv->attrVal[i].numVals == 1) {
356 				bp2buf(myself, &b, "=");
357 				if (rv->attrVal[i].type == vt_string)
358 					sbc2buf(myself,
359 						rv->attrVal[i].val[0].value,
360 						rv->attrVal[i].val[0].length,
361 						&b);
362 				else
363 					bc2buf(myself,
364 						rv->attrVal[i].val[0].value,
365 						rv->attrVal[i].val[0].length,
366 						&b);
367 				bp2buf(myself, &b, "\n");
368 			} else {
369 				bp2buf(myself, &b, "\n");
370 				for (j = 0; j < rv->attrVal[i].numVals; j++) {
371 					bp2buf(myself, &b, "\t\t");
372 					if (rv->attrVal[i].type == vt_string)
373 						sbc2buf(myself,
374 						rv->attrVal[i].val[j].value,
375 						rv->attrVal[i].val[j].length,
376 						&b);
377 					else
378 						bc2buf(myself,
379 						rv->attrVal[i].val[j].value,
380 						rv->attrVal[i].val[j].length,
381 						&b);
382 					bp2buf(myself, &b, "\n");
383 				}
384 			}
385 		}
386 	}
387 
388 	c2buf(myself, b.buf, b.len);
389 	sfree(b.buf);
390 	printbuf();
391 }
392 
393 void
printLdapMod(LDAPMod ** mods,__nis_buffer_t * b)394 printLdapMod(LDAPMod **mods, __nis_buffer_t *b) {
395 	LDAPMod		*m;
396 	char		*s;
397 	char		*myself = "printLdapMod";
398 
399 	if (mods == 0)
400 		return;
401 
402 	if (b == 0)
403 		b = &pb;
404 
405 	while ((m = *mods) != 0) {
406 		if ((m->mod_op & LDAP_MOD_ADD) != 0 ||
407 				(m->mod_op & ~LDAP_MOD_BVALUES) == 0) {
408 			s = "ADD    ";
409 		} else if ((m->mod_op & LDAP_MOD_DELETE) != 0) {
410 			s = "DELETE ";
411 		} else if ((m->mod_op & LDAP_MOD_REPLACE) != 0) {
412 			s = "REPLACE";
413 		} else {
414 			s = "UNKNOWN";
415 		}
416 		bp2buf(myself, b, "%s: %s\n", s, m->mod_type);
417 		if ((m->mod_op & LDAP_MOD_BVALUES) == 0) {
418 			char	**v = m->mod_values;
419 
420 			if (v != 0) {
421 				while (*v != 0) {
422 					bp2buf(myself, b, "\t%s\n", *v);
423 					v++;
424 				}
425 			}
426 		} else {
427 			struct berval	**bv = m->mod_bvalues;
428 
429 			if (bv != 0) {
430 				while (*bv != 0) {
431 					bp2buf(myself, b, "\t<ber> %d bytes\n",
432 						(*bv)->bv_len);
433 					bv++;
434 				}
435 			}
436 		}
437 		mods++;
438 	}
439 }
440 
441 static void
printObjRights(char * msg,void * access)442 printObjRights(char *msg, void *access) {
443 	uchar_t	*a = access;
444 	int	i;
445 
446 	if (a == 0)
447 		return;
448 
449 	for (i = 0; i < 4; i++) {
450 		p2buf(msg, "%s", (a[i] & NIS_READ_ACC) ? "r" : "-");
451 		p2buf(msg, "%s", (a[i] & NIS_MODIFY_ACC) ? "m" : "-");
452 		p2buf(msg, "%s", (a[i] & NIS_CREATE_ACC) ? "c" : "-");
453 		p2buf(msg, "%s", (a[i] & NIS_DESTROY_ACC) ? "d" : "-");
454 	}
455 }
456 
457 void
printObjAttr(__nis_obj_attr_t * attr)458 printObjAttr(__nis_obj_attr_t *attr) {
459 	char	*myself = "printObjAttr";
460 
461 	if (attr == 0)
462 		return;
463 
464 	p2buf(myself, "\tzo_owner  = %s\n", NIL(attr->zo_owner));
465 	p2buf(myself, "\tzo_group  = %s\n", NIL(attr->zo_group));
466 	p2buf(myself, "\tzo_domain = %s\n", NIL(attr->zo_domain));
467 	p2buf(myself, "\tzo_access = ");
468 	printObjRights(myself, &attr->zo_access);
469 	p2buf(myself, " (0x%08x)\n", attr->zo_access);
470 	p2buf(myself, "\tzo_ttl    = %d\n", attr->zo_ttl);
471 }
472