Named ACLs: Introduces a system for creating and sharing ACLs

This patch adds Named ACL functionality to Asterisk. This allows system
administrators to define an ACL and refer to it by a unique name. Configurable
items can then refer to that name when specifying access control lists.
It also includes updates to all core supported consumers of ACLs. That includes
manager, chan_sip, and chan_iax2. This feature is based on the deluxepine-trunk
by Olle E. Johansson and provides a subset of the Named ACL functionality
implemented in that branch. For more information on this feature, see acl.conf
and/or the Asterisk wiki.

Review: https://reviewboard.asterisk.org/r/1978/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@369959 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 135 insertions, 0 deletions

diff --git a/main/config.c b/main/config.c
index 9e2df6c43..fee6d9eb7 100644
--- a/main/config.c
+++ b/main/config.c
@@ -773,6 +773,124 @@ struct ast_variable *ast_category_root(struct ast_config *config, char *cat)
 	return NULL;
 }
 
+void ast_config_sort_categories(struct ast_config *config, int descending,
+								int (*comparator)(struct ast_category *p, struct ast_category *q))
+{
+	/*
+	 * The contents of this function are adapted from
+	 * an example of linked list merge sorting
+	 * copyright 2001 Simon Tatham.
+	 *
+	 * Permission is hereby granted, free of charge, to any person
+	 * obtaining a copy of this software and associated documentation
+	 * files (the "Software"), to deal in the Software without
+	 * restriction, including without limitation the rights to use,
+	 * copy, modify, merge, publish, distribute, sublicense, and/or
+	 * sell copies of the Software, and to permit persons to whom the
+	 * Software is furnished to do so, subject to the following
+	 * conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be
+	 * included in all copies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+	 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+	 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+	 * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
+	 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+	 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+	 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	 * SOFTWARE.
+	 */
+
+	int insize = 1;
+	struct ast_category *p, *q, *e, *tail;
+	int nmerges, psize, qsize, i;
+
+	/* If the descending flag was sent, we'll apply inversion to the comparison function's return. */
+	if (descending) {
+		descending = -1;
+	} else {
+		descending = 1;
+	}
+
+	if (!config->root) {
+		return;
+	}
+
+	while (1) {
+		p = config->root;
+		config->root = NULL;
+		tail = NULL;
+
+		nmerges = 0; /* count number of merges we do in this pass */
+
+		while (p) {
+			nmerges++; /* there exists a merge to be done */
+
+			/* step `insize' places along from p */
+			q = p;
+			psize = 0;
+			for (i = 0; i < insize; i++) {
+				psize++;
+				q = q->next;
+				if (!q) {
+					break;
+				}
+			}
+
+			/* if q hasn't fallen off end, we have two lists to merge */
+			qsize = insize;
+
+			/* now we have two lists; merge them */
+			while (psize > 0 || (qsize > 0 && q)) {
+				/* decide whether next element of merge comes from p or q */
+				if (psize == 0) {
+					/* p is empty; e must come from q. */
+					e = q;
+					q = q->next;
+					qsize--;
+				} else if (qsize == 0 || !q) {
+					/* q is empty; e must come from p. */
+					e = p; p = p->next; psize--;
+				} else if ((comparator(p,q) * descending) <= 0) {
+					/* First element of p is lower (or same) e must come from p. */
+					e = p;
+					p = p->next;
+					psize--;
+				} else {
+					/* First element of q is lower; e must come from q. */
+					e = q;
+					q = q->next;
+					qsize--;
+				}
+
+				/* add the next element to the merged list */
+				if (tail) {
+					tail->next = e;
+				} else {
+					config->root = e;
+				}
+				tail = e;
+			}
+
+			/* now p has stepped `insize' places along, and q has too */
+			p = q;
+		}
+
+		tail->next = NULL;
+
+		/* If we have done only one merge, we're finished. */
+		if (nmerges <= 1) { /* allow for nmerges==0, the empty list case */
+			return;
+		}
+
+		/* Otherwise repeat, merging lists twice the size */
+		insize *= 2;
+	}
+
+}
+
 char *ast_category_browse(struct ast_config *config, const char *prev)
 {
 	struct ast_category *cat;
@@ -2244,6 +2362,23 @@ int ast_config_engine_deregister(struct ast_config_engine *del)
 	return 0;
 }
 
+int ast_realtime_is_mapping_defined(const char *family)
+{
+	struct ast_config_map *map;
+	ast_mutex_lock(&config_lock);
+
+	for (map = config_maps; map; map = map->next) {
+		if (!strcasecmp(family, map->name)) {
+			ast_mutex_unlock(&config_lock);
+			return 1;
+		}
+	}
+
+	ast_mutex_unlock(&config_lock);
+
+	return 0;
+}
+
 /*! \brief Find realtime engine for realtime family */
 static struct ast_config_engine *find_engine(const char *family, int priority, char *database, int dbsiz, char *table, int tabsiz)
 {