xref: /illumos-gate/usr/src/lib/gss_mechs/mech_krb5/profile/prof_tree.c (revision 55fea89dcaa64928bed4327112404dcb3e07b79f)
1 /*
2  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 
7 /*
8  * prof_tree.c --- these routines maintain the parse tree of the
9  * 	config file.
10  *
11  * All of the details of how the tree is stored is abstracted away in
12  * this file; all of the other profile routines build, access, and
13  * modify the tree via the accessor functions found in this file.
14  *
15  * Each node may represent either a relation or a section header.
16  *
17  * A section header must have its value field set to 0, and may a one
18  * or more child nodes, pointed to by first_child.
19  *
20  * A relation has as its value a pointer to allocated memory
21  * containing a string.  Its first_child pointer must be null.
22  *
23  */
24 
25 
26 #include "prof_int.h"
27 
28 #include <stdio.h>
29 #include <string.h>
30 #ifdef HAVE_STDLIB_H
31 #include <stdlib.h>
32 #endif
33 #include <errno.h>
34 #include <ctype.h>
35 
36 struct profile_node {
37 	errcode_t	magic;
38 	char *name;
39 	char *value;
40 	int group_level;
41 	int final:1;		/* Indicate don't search next file */
42 	int deleted:1;
43 	struct profile_node *first_child;
44 	struct profile_node *parent;
45 	struct profile_node *next, *prev;
46 };
47 
48 #define CHECK_MAGIC(node) \
49 	  if ((node)->magic != PROF_MAGIC_NODE) \
50 		  return PROF_MAGIC_NODE;
51 
52 /*
53  * Free a node, and any children
54  */
profile_free_node(struct profile_node * node)55 void profile_free_node(struct profile_node *node)
56 {
57 	struct profile_node *child, *next;
58 
59 	if (node->magic != PROF_MAGIC_NODE)
60 		return;
61 
62 	if (node->name)
63 		free(node->name);
64 	if (node->value)
65 		free(node->value);
66 
67 	for (child=node->first_child; child; child = next) {
68 		next = child->next;
69 		profile_free_node(child);
70 	}
71 	node->magic = 0;
72 
73 	free(node);
74 }
75 
76 #ifndef HAVE_STRDUP
77 #undef strdup
78 #define strdup MYstrdup
MYstrdup(const char * s)79 static char *MYstrdup (const char *s)
80 {
81     size_t sz = strlen(s) + 1;
82     char *p = malloc(sz);
83     if (p != 0)
84 	memcpy(p, s, sz);
85     return p;
86 }
87 #endif
88 
89 /*
90  * Create a node
91  */
profile_create_node(const char * name,const char * value,struct profile_node ** ret_node)92 errcode_t profile_create_node(const char *name, const char *value,
93 			      struct profile_node **ret_node)
94 {
95 	struct profile_node *new;
96 
97 	new = malloc(sizeof(struct profile_node));
98 	if (!new)
99 		return ENOMEM;
100 	memset(new, 0, sizeof(struct profile_node));
101 	new->name = strdup(name);
102 	if (new->name == 0) {
103 	    profile_free_node(new);
104 	    return ENOMEM;
105 	}
106 	if (value) {
107 		new->value = strdup(value);
108 		if (new->value == 0) {
109 		    profile_free_node(new);
110 		    return ENOMEM;
111 		}
112 	}
113 	new->magic = PROF_MAGIC_NODE;
114 
115 	*ret_node = new;
116 	return 0;
117 }
118 
119 /*
120  * This function verifies that all of the representation invarients of
121  * the profile are true.  If not, we have a programming bug somewhere,
122  * probably in this file.
123  */
profile_verify_node(struct profile_node * node)124 errcode_t profile_verify_node(struct profile_node *node)
125 {
126 	struct profile_node *p, *last;
127 	errcode_t	retval;
128 
129 	CHECK_MAGIC(node);
130 
131 	if (node->value && node->first_child)
132 		return PROF_SECTION_WITH_VALUE;
133 
134 	last = 0;
135 	for (p = node->first_child; p; last = p, p = p->next) {
136 		if (p->prev != last)
137 			return PROF_BAD_LINK_LIST;
138 		if (last && (last->next != p))
139 			return PROF_BAD_LINK_LIST;
140 		if (node->group_level+1 != p->group_level)
141 			return PROF_BAD_GROUP_LVL;
142 		if (p->parent != node)
143 			return PROF_BAD_PARENT_PTR;
144 		retval = profile_verify_node(p);
145 		if (retval)
146 			return retval;
147 	}
148 	return 0;
149 }
150 
151 /*
152  * Add a node to a particular section
153  */
profile_add_node(struct profile_node * section,const char * name,const char * value,struct profile_node ** ret_node)154 errcode_t profile_add_node(struct profile_node *section, const char *name,
155 			   const char *value, struct profile_node **ret_node)
156 {
157 	errcode_t retval;
158 	struct profile_node *p, *last, *new;
159 
160 	CHECK_MAGIC(section);
161 
162 	if (section->value)
163 		return PROF_ADD_NOT_SECTION;
164 
165 	/*
166 	 * Find the place to insert the new node.  We look for the
167 	 * place *after* the last match of the node name, since
168 	 * order matters.
169 	 */
170 	for (p=section->first_child, last = 0; p; last = p, p = p->next) {
171 		int cmp;
172 		cmp = strcmp(p->name, name);
173 		if (cmp > 0)
174 			break;
175 	}
176 	retval = profile_create_node(name, value, &new);
177 	if (retval)
178 		return retval;
179 	new->group_level = section->group_level+1;
180 	new->deleted = 0;
181 	new->parent = section;
182 	new->prev = last;
183 	new->next = p;
184 	if (p)
185 		p->prev = new;
186 	if (last)
187 		last->next = new;
188 	else
189 		section->first_child = new;
190 	if (ret_node)
191 		*ret_node = new;
192 	return 0;
193 }
194 
195 /*
196  * Set the final flag on a particular node.
197  */
profile_make_node_final(struct profile_node * node)198 errcode_t profile_make_node_final(struct profile_node *node)
199 {
200 	CHECK_MAGIC(node);
201 
202 	node->final = 1;
203 	return 0;
204 }
205 
206 /*
207  * Check the final flag on a node
208  */
profile_is_node_final(struct profile_node * node)209 int profile_is_node_final(struct profile_node *node)
210 {
211 	return (node->final != 0);
212 }
213 
214 /*
215  * Return the name of a node.  (Note: this is for internal functions
216  * only; if the name needs to be returned from an exported function,
217  * strdup it first!)
218  */
profile_get_node_name(struct profile_node * node)219 const char *profile_get_node_name(struct profile_node *node)
220 {
221 	return node->name;
222 }
223 
224 /*
225  * Return the value of a node.  (Note: this is for internal functions
226  * only; if the name needs to be returned from an exported function,
227  * strdup it first!)
228  */
profile_get_node_value(struct profile_node * node)229 const char *profile_get_node_value(struct profile_node *node)
230 {
231 	return node->value;
232 }
233 
234 /*
235  * Iterate through the section, returning the nodes which match
236  * the given name.  If name is NULL, then interate through all the
237  * nodes in the section.  If section_flag is non-zero, only return the
238  * section which matches the name; don't return relations.  If value
239  * is non-NULL, then only return relations which match the requested
240  * value.  (The value argument is ignored if section_flag is non-zero.)
241  *
242  * The first time this routine is called, the state pointer must be
243  * null.  When this profile_find_node_relation() returns, if the state
244  * pointer is non-NULL, then this routine should be called again.
245  * (This won't happen if section_flag is non-zero, obviously.)
246  *
247  */
profile_find_node(struct profile_node * section,const char * name,const char * value,int section_flag,void ** state,struct profile_node ** node)248 errcode_t profile_find_node(struct profile_node *section, const char *name,
249 			    const char *value, int section_flag, void **state,
250 			    struct profile_node **node)
251 {
252 	struct profile_node *p;
253 
254 	CHECK_MAGIC(section);
255 	p = *state;
256 	if (p) {
257 		CHECK_MAGIC(p);
258 	} else
259 		p = section->first_child;
260 
261 	for (; p; p = p->next) {
262 		if (name && (strcmp(p->name, name)))
263 			continue;
264 		if (section_flag) {
265 			if (p->value)
266 				continue;
267 		} else {
268 			if (!p->value)
269 				continue;
270 			if (value && (strcmp(p->value, value)))
271 				continue;
272 		}
273 		if (p->deleted)
274 		    continue;
275 		/* A match! */
276 		if (node)
277 			*node = p;
278 		break;
279 	}
280 	if (p == 0) {
281 		*state = 0;
282 		return section_flag ? PROF_NO_SECTION : PROF_NO_RELATION;
283 	}
284 	/*
285 	 * OK, we've found one match; now let's try to find another
286 	 * one.  This way, if we return a non-zero state pointer,
287 	 * there's guaranteed to be another match that's returned.
288 	 */
289 	for (p = p->next; p; p = p->next) {
290 		if (name && (strcmp(p->name, name)))
291 			continue;
292 		if (section_flag) {
293 			if (p->value)
294 				continue;
295 		} else {
296 			if (!p->value)
297 				continue;
298 			if (value && (strcmp(p->value, value)))
299 				continue;
300 		}
301 		/* A match! */
302 		break;
303 	}
304 	*state = p;
305 	return 0;
306 }
307 
308 
309 /*
310  * Iterate through the section, returning the relations which match
311  * the given name.  If name is NULL, then interate through all the
312  * relations in the section.  The first time this routine is called,
313  * the state pointer must be null.  When this profile_find_node_relation()
314  * returns, if the state pointer is non-NULL, then this routine should
315  * be called again.
316  *
317  * The returned character string in value points to the stored
318  * character string in the parse string.  Before this string value is
319  * returned to a calling application (profile_find_node_relation is not an
320  * exported interface), it should be strdup()'ed.
321  */
profile_find_node_relation(struct profile_node * section,const char * name,void ** state,char ** ret_name,char ** value)322 errcode_t profile_find_node_relation(struct profile_node *section,
323 				     const char *name, void **state,
324 				     char **ret_name, char **value)
325 {
326 	struct profile_node *p;
327 	errcode_t	retval;
328 
329 	retval = profile_find_node(section, name, 0, 0, state, &p);
330 	if (retval)
331 		return retval;
332 
333 	if (p) {
334 		if (value)
335 			*value = p->value;
336 		if (ret_name)
337 			*ret_name = p->name;
338 	}
339 	return 0;
340 }
341 
342 /*
343  * Iterate through the section, returning the subsections which match
344  * the given name.  If name is NULL, then interate through all the
345  * subsections in the section.  The first time this routine is called,
346  * the state pointer must be null.  When this profile_find_node_subsection()
347  * returns, if the state pointer is non-NULL, then this routine should
348  * be called again.
349  *
350  * This is (plus accessor functions for the name and value given a
351  * profile node) makes this function mostly syntactic sugar for
352  * profile_find_node.
353  */
profile_find_node_subsection(struct profile_node * section,const char * name,void ** state,char ** ret_name,struct profile_node ** subsection)354 errcode_t profile_find_node_subsection(struct profile_node *section,
355 				       const char *name, void **state,
356 				       char **ret_name,
357 				       struct profile_node **subsection)
358 {
359 	struct profile_node *p;
360 	errcode_t	retval;
361 
362 	/* Solaris Kerberos */
363 	if (section == (struct profile_node *)NULL)
364 		return (PROF_NO_PROFILE);
365 
366 	retval = profile_find_node(section, name, 0, 1, state, &p);
367 	if (retval)
368 		return retval;
369 
370 	if (p) {
371 		if (subsection)
372 			*subsection = p;
373 		if (ret_name)
374 			*ret_name = p->name;
375 	}
376 	return 0;
377 }
378 
379 /*
380  * This function returns the parent of a particular node.
381  */
profile_get_node_parent(struct profile_node * section,struct profile_node ** parent)382 errcode_t profile_get_node_parent(struct profile_node *section,
383 				  struct profile_node **parent)
384 {
385 	*parent = section->parent;
386 	return 0;
387 }
388 
389 /*
390  * This is a general-purpose iterator for returning all nodes that
391  * match the specified name array.
392  */
393 struct profile_iterator {
394 	prf_magic_t		magic;
395 	profile_t		profile;
396 	int			flags;
397 	const char 		*const *names;
398 	const char		*name;
399 	prf_file_t		file;
400 	int			file_serial;
401 	int			done_idx;
402 	struct profile_node 	*node;
403 	int			num;
404 };
405 
profile_node_iterator_create(profile_t profile,const char * const * names,int flags,void ** ret_iter)406 errcode_t profile_node_iterator_create(profile_t profile,
407 				       const char *const *names, int flags,
408 				       void **ret_iter)
409 {
410 	struct profile_iterator *iter;
411 	int	done_idx = 0;
412 
413 	if (profile == 0)
414 		return PROF_NO_PROFILE;
415 	if (profile->magic != PROF_MAGIC_PROFILE)
416 		return PROF_MAGIC_PROFILE;
417 	if (!names)
418 		return PROF_BAD_NAMESET;
419 	if (!(flags & PROFILE_ITER_LIST_SECTION)) {
420 		if (!names[0])
421 			return PROF_BAD_NAMESET;
422 		done_idx = 1;
423 	}
424 
425 	if ((iter = malloc(sizeof(struct profile_iterator))) == NULL)
426 		return ENOMEM;
427 
428 	iter->magic = PROF_MAGIC_ITERATOR;
429 	iter->profile = profile;
430 	iter->names = names;
431 	iter->flags = flags;
432 	iter->file = profile->first_file;
433 	iter->done_idx = done_idx;
434 	iter->node = 0;
435 	iter->num = 0;
436 	*ret_iter = iter;
437 	return 0;
438 }
439 
profile_node_iterator_free(void ** iter_p)440 void profile_node_iterator_free(void **iter_p)
441 {
442 	struct profile_iterator *iter;
443 
444 	if (!iter_p)
445 		return;
446 	iter = *iter_p;
447 	if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
448 		return;
449 	free(iter);
450 	*iter_p = 0;
451 }
452 
453 /*
454  * Note: the returned character strings in ret_name and ret_value
455  * points to the stored character string in the parse string.  Before
456  * this string value is returned to a calling application
457  * (profile_node_iterator is not an exported interface), it should be
458  * strdup()'ed.
459  */
profile_node_iterator(void ** iter_p,struct profile_node ** ret_node,char ** ret_name,char ** ret_value)460 errcode_t profile_node_iterator(void **iter_p, struct profile_node **ret_node,
461 				char **ret_name, char **ret_value)
462 {
463 	struct profile_iterator 	*iter = *iter_p;
464 	struct profile_node 		*section, *p;
465 	const char			*const *cpp;
466 	errcode_t			retval;
467 	int				skip_num = 0;
468 
469 	if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
470 		return PROF_MAGIC_ITERATOR;
471 	if (iter->file && iter->file->magic != PROF_MAGIC_FILE)
472 	    return PROF_MAGIC_FILE;
473 	if (iter->file && iter->file->data->magic != PROF_MAGIC_FILE_DATA)
474 	    return PROF_MAGIC_FILE_DATA;
475 	/*
476 	 * If the file has changed, then the node pointer is invalid,
477 	 * so we'll have search the file again looking for it.
478 	 */
479 	if (iter->file) {
480 	    retval = k5_mutex_lock(&iter->file->data->lock);
481 	    if (retval)
482 		return retval;
483 	}
484 	if (iter->node && (iter->file->data->upd_serial != iter->file_serial)) {
485 		iter->flags &= ~PROFILE_ITER_FINAL_SEEN;
486 		skip_num = iter->num;
487 		iter->node = 0;
488 	}
489 	if (iter->node && iter->node->magic != PROF_MAGIC_NODE) {
490 	    if (iter->file)
491 		k5_mutex_unlock(&iter->file->data->lock);
492 	    return PROF_MAGIC_NODE;
493 	}
494 get_new_file:
495 	if (iter->node == 0) {
496 		if (iter->file == 0 ||
497 		    (iter->flags & PROFILE_ITER_FINAL_SEEN)) {
498 			if (iter->file)
499 			    k5_mutex_unlock(&iter->file->data->lock);
500 			profile_node_iterator_free(iter_p);
501 			if (ret_node)
502 				*ret_node = 0;
503 			if (ret_name)
504 				*ret_name = 0;
505 			if (ret_value)
506 				*ret_value =0;
507 			return 0;
508 		}
509 		k5_mutex_unlock(&iter->file->data->lock);
510 		if ((retval = profile_update_file(iter->file))) {
511 		    if (retval == ENOENT || retval == EACCES) {
512 			/* XXX memory leak? */
513 			iter->file = iter->file->next;
514 			if (iter->file) {
515 			    retval = k5_mutex_lock(&iter->file->data->lock);
516 			    if (retval) {
517 				profile_node_iterator_free(iter_p);
518 				return retval;
519 			    }
520 			}
521 			skip_num = 0;
522 			retval = 0;
523 			goto get_new_file;
524 		    } else {
525 			profile_node_iterator_free(iter_p);
526 			return retval;
527 		    }
528 		}
529 		retval = k5_mutex_lock(&iter->file->data->lock);
530 		if (retval) {
531 		    profile_node_iterator_free(iter_p);
532 		    return retval;
533 		}
534 		iter->file_serial = iter->file->data->upd_serial;
535 		/*
536 		 * Find the section to list if we are a LIST_SECTION,
537 		 * or find the containing section if not.
538 		 */
539 		section = iter->file->data->root;
540 		assert(section != NULL);
541 		for (cpp = iter->names; cpp[iter->done_idx]; cpp++) {
542 			for (p=section->first_child; p; p = p->next) {
543 				if (!strcmp(p->name, *cpp) && !p->value)
544 					break;
545 			}
546 			if (!p) {
547 				section = 0;
548 				break;
549 			}
550 			section = p;
551 			if (p->final)
552 				iter->flags |= PROFILE_ITER_FINAL_SEEN;
553 		}
554 		if (!section) {
555 			k5_mutex_unlock(&iter->file->data->lock);
556 			iter->file = iter->file->next;
557 			if (iter->file) {
558 			    retval = k5_mutex_lock(&iter->file->data->lock);
559 			    if (retval) {
560 				profile_node_iterator_free(iter_p);
561 				return retval;
562 			    }
563 			}
564 			skip_num = 0;
565 			goto get_new_file;
566 		}
567 		iter->name = *cpp;
568 		iter->node = section->first_child;
569 	}
570 	/*
571 	 * OK, now we know iter->node is set up correctly.  Let's do
572 	 * the search.
573 	 */
574 	for (p = iter->node; p; p = p->next) {
575 		if (iter->name && strcmp(p->name, iter->name))
576 			continue;
577 		if ((iter->flags & PROFILE_ITER_SECTIONS_ONLY) &&
578 		    p->value)
579 			continue;
580 		if ((iter->flags & PROFILE_ITER_RELATIONS_ONLY) &&
581 		    !p->value)
582 			continue;
583 		if (skip_num > 0) {
584 			skip_num--;
585 			continue;
586 		}
587 		if (p->deleted)
588 			continue;
589 		break;
590 	}
591 	iter->num++;
592 	if (!p) {
593 		k5_mutex_unlock(&iter->file->data->lock);
594 		iter->file = iter->file->next;
595 		if (iter->file) {
596 		    retval = k5_mutex_lock(&iter->file->data->lock);
597 		    if (retval) {
598 			profile_node_iterator_free(iter_p);
599 			return retval;
600 		    }
601 		}
602 		iter->node = 0;
603 		skip_num = 0;
604 		goto get_new_file;
605 	}
606 	k5_mutex_unlock(&iter->file->data->lock);
607 	if ((iter->node = p->next) == NULL)
608 		iter->file = iter->file->next;
609 	if (ret_node)
610 		*ret_node = p;
611 	if (ret_name)
612 		*ret_name = p->name;
613 	if (ret_value)
614 		*ret_value = p->value;
615 	return 0;
616 }
617 
618 /*
619  * Remove a particular node.
620  *
621  * TYT, 2/25/99
622  */
profile_remove_node(struct profile_node * node)623 errcode_t profile_remove_node(struct profile_node *node)
624 {
625 	CHECK_MAGIC(node);
626 
627 	if (node->parent == 0)
628 		return PROF_EINVAL; /* Can't remove the root! */
629 
630 	node->deleted = 1;
631 
632 	return 0;
633 }
634 
635 /*
636  * Set the value of a specific node containing a relation.
637  *
638  * TYT, 2/25/99
639  */
profile_set_relation_value(struct profile_node * node,const char * new_value)640 errcode_t profile_set_relation_value(struct profile_node *node,
641 				     const char *new_value)
642 {
643 	char	*cp;
644 
645 	CHECK_MAGIC(node);
646 
647 	if (!node->value)
648 		return PROF_SET_SECTION_VALUE;
649 
650 	cp = malloc(strlen(new_value)+1);
651 	if (!cp)
652 		return ENOMEM;
653 
654 	strcpy(cp, new_value);
655 	free(node->value);
656 	node->value = cp;
657 
658 	return 0;
659 }
660 
661 /*
662  * Rename a specific node
663  *
664  * TYT 2/25/99
665  */
profile_rename_node(struct profile_node * node,const char * new_name)666 errcode_t profile_rename_node(struct profile_node *node, const char *new_name)
667 {
668 	char			*new_string;
669 	struct profile_node 	*p, *last;
670 
671 	CHECK_MAGIC(node);
672 
673 	if (strcmp(new_name, node->name) == 0)
674 		return 0;	/* It's the same name, return */
675 
676 	/*
677 	 * Make sure we can allocate memory for the new name, first!
678 	 */
679 	new_string = malloc(strlen(new_name)+1);
680 	if (!new_string)
681 		return ENOMEM;
682 	strcpy(new_string, new_name);
683 
684 	/*
685 	 * Find the place to where the new node should go.  We look
686 	 * for the place *after* the last match of the node name,
687 	 * since order matters.
688 	 */
689 	for (p=node->parent->first_child, last = 0; p; last = p, p = p->next) {
690 		if (strcmp(p->name, new_name) > 0)
691 			break;
692 	}
693 
694 	/*
695 	 * If we need to move the node, do it now.
696 	 */
697 	if ((p != node) && (last != node)) {
698 		/*
699 		 * OK, let's detach the node
700 		 */
701 		if (node->prev)
702 			node->prev->next = node->next;
703 		else
704 			node->parent->first_child = node->next;
705 		if (node->next)
706 			node->next->prev = node->prev;
707 
708 		/*
709 		 * Now let's reattach it in the right place.
710 		 */
711 		if (p)
712 			p->prev = node;
713 		if (last)
714 			last->next = node;
715 		else
716 			node->parent->first_child = node;
717 		node->next = p;
718 		node->prev = last;
719 	}
720 
721 	free(node->name);
722 	node->name = new_string;
723 	return 0;
724 }
725