Version 0.1.9 from FTP
[asterisk/asterisk.git] / pbx / pbx_config.c
index 24b0bbe..fc5bc25 100755 (executable)
 #include <asterisk/config.h>
 #include <asterisk/module.h>
 #include <asterisk/logger.h>
+#include <asterisk/cli.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
+#include <errno.h>
 /* For where to put dynamic tables */
 #include "../asterisk.h"
 
@@ -26,9 +29,1432 @@ static char *config = "extensions.conf";
 static char *registrar = "pbx_config";
 
 static int static_config = 0;
+static int write_protect_config = 1;
 
+static pthread_mutex_t save_dialplan_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Help for commands provided by this module ...
+ */
+static char context_dont_include_help[] =
+"Usage: dont include context in include\n"
+"       Remove include from context.\n";
+
+static char context_remove_extension_help[] =
+"Usage: remove extension exten@context [priority]\n"
+"       Remove whole extension from context. If priority is set, we are only\n"
+"       removing extension with given priority.\n";
+
+static char context_add_include_help[] =
+"Usage: include context in context\n"
+"       Include context in other context.\n";
+
+static char save_dialplan_help[] =
+"Usage: save dialplan [/path/to/extension/file]\n"
+"       Save dialplan created by pbx_config module.\n"
+"\n"
+"Example: save dialplan                 (/etc/asterisk/extensions.conf)\n"
+"         save dialplan /home/markster  (/home/markster/extensions.conf)\n";
+
+static char context_add_extension_help[] =
+"Usage: add extension <exten>,<priority>,<app>,<app-data> into <context>\n"
+"       [replace]\n\n"
+"       This command will add new extension into <context>. If there is an\n"
+"       existence of extension with the same priority and last 'replace'\n"
+"       arguments is given here we simply replace this extension.\n"
+"\n"
+"Example: add extension 6123,1,Dial,IAX/216.207.245.56/6123 into local\n"
+"         Now, you can dial 6123 and talk to Markster :)\n";
+
+static char context_add_ignorepat_help[] =
+"Usage: add ignorepat <pattern> into <context>\n"
+"       This command add new ignore pattern into context <context>\n"
+"\n"
+"Example: add ignorepat _3XX into local\n";
+
+static char context_remove_ignorepat_help[] =
+"Usage: remove ignorepat <pattern> from <context>\n"
+"       This command remove ignore pattern from context <context>\n"
+"\n"
+"Example: remove ignorepat _3XX from local\n";
+
+/*
+ * Implementation of functions provided by this module
+ */
+
+/*
+ * REMOVE INCLUDE command stuff
+ */
+static int handle_context_dont_include(int fd, int argc, char *argv[])
+{
+       if (argc != 5) return RESULT_SHOWUSAGE;
+
+       if (strcmp(argv[3], "in")) return RESULT_SHOWUSAGE;
+
+       if (!ast_context_remove_include(argv[4], argv[2], registrar)) {
+               ast_cli(fd, "We are not including '%s' in '%s' now\n",
+                       argv[2], argv[4]);
+               return RESULT_SUCCESS;
+       }
+
+       ast_cli(fd, "Failed to remove '%s' include from '%s' context\n",
+               argv[2], argv[4]);
+       return RESULT_FAILURE;
+}
+
+static char *complete_context_dont_include(char *line, char *word,
+       int pos, int state)
+{
+       int which = 0;
+
+       /*
+        * Context completion ...
+        */
+       if (pos == 2) {
+               struct ast_context *c;
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+                       return NULL;
+               }
+
+               /* walk pbx_get_contexts ... */
+               c = ast_walk_contexts(NULL); 
+               while (c) {
+                       struct ast_include *i;
+
+                       if (ast_lock_context(c)) {
+                               c = ast_walk_contexts(c);
+                               continue;
+                       }
+
+                       i = ast_walk_context_includes(c, NULL);
+                       while (i) {
+                               if (!strlen(word) ||
+                                       !strncmp(ast_get_include_name(i), word, strlen(word))) {
+                                       struct ast_context *nc;
+                                       int already_served = 0;
+
+                                       /* check if this include is already served or not */
+
+                                       /* go through all contexts again till we reach actuall
+                                        * context or already_served = 1
+                                        */
+                                       nc = ast_walk_contexts(NULL);
+                                       while (nc && nc != c && !already_served) {
+                                               if (!ast_lock_context(nc)) {
+                                                       struct ast_include *ni;
+
+                                                       ni = ast_walk_context_includes(nc, NULL);
+                                                       while (ni && !already_served) {
+                                                               if (!strcmp(ast_get_include_name(i),
+                                                                       ast_get_include_name(ni)))
+                                                                       already_served = 1;
+                                                               ni = ast_walk_context_includes(nc, ni);
+                                                       }       
+                                                       
+                                                       ast_unlock_context(nc);
+                                               }
+                                               nc = ast_walk_contexts(nc);
+                                       }
+
+                                       if (!already_served) {
+                                               if (++which > state) {
+                                                       char *res =
+                                                               strdup(ast_get_include_name(i));
+                                                       ast_unlock_context(c);
+                                                       ast_unlock_contexts();
+                                                       return res;
+                                               }
+                                       }
+                               }
+                               i = ast_walk_context_includes(c, i);
+                       }
+
+                       ast_unlock_context(c);
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       /*
+        * 'in' completion ... (complete only if previous context is really
+        * included somewhere)
+        */
+       if (pos == 3) {
+               struct ast_context *c;
+               char *context, *dupline, *duplinet;
+
+               if (state > 0) return NULL;
+
+               /* take 'context' from line ... */
+               if (!(dupline = strdup(line))) {
+                       ast_log(LOG_ERROR, "Out of free memory\n");
+                       return NULL;
+               }
+
+               duplinet = dupline;
+               strsep(&duplinet, " "); /* skip 'dont' */
+               strsep(&duplinet, " "); /* skip 'include' */
+               context = strsep(&duplinet, " ");
+
+               if (!context) {
+                       free(dupline);
+                       return NULL;
+               }
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_WARNING, "Failed to lock contexts list\n");
+                       free(dupline);
+                       return NULL;
+               }
+
+               /* go through all contexts and check if is included ... */
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       struct ast_include *i;
+                       if (ast_lock_context(c)) {
+                               free(dupline);
+                               ast_unlock_contexts();
+                               return NULL;
+                       }
+
+                       i = ast_walk_context_includes(c, NULL);
+                       while (i) {
+                               /* is it our context? */
+                               if (!strcmp(ast_get_include_name(i), context)) {
+                                       /* yes, it is, context is really included, so
+                                        * complete "in" command
+                                        */
+                                       free(dupline);
+                                       ast_unlock_context(c);
+                                       ast_unlock_contexts();
+                                       return strdup("in");
+                               }
+                               i = ast_walk_context_includes(c, i);
+                       }
+                       ast_unlock_context(c);
+                       c = ast_walk_contexts(c);
+               }
+               free(dupline);
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       /*
+        * Context from which we removing include ... 
+        */
+       if (pos == 4) {
+               struct ast_context *c;
+               char *context, *dupline, *duplinet, *in;
+
+               if (!(dupline = strdup(line))) {
+                       ast_log(LOG_ERROR, "Out of free memory\n");
+                       return NULL;
+               }
+
+               duplinet = dupline;
+
+               strsep(&duplinet, " "); /* skip 'dont' */
+               strsep(&duplinet, " "); /* skip 'include' */
+
+               if (!(context = strsep(&duplinet, " "))) {
+                       free(dupline);
+                       return NULL;
+               }
+
+               /* third word must be in */
+               in = strsep(&duplinet, " ");
+               if (!in ||
+                       strcmp(in, "in")) {
+                       free(dupline);
+                       return NULL;
+               }
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+                       free(dupline);
+                       return NULL;
+               }
+
+               /* walk through all contexts ... */
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       struct ast_include *i;
+                       if (ast_lock_context(c)) {
+                               free(dupline);
+                               return NULL;
+                       }
+       
+                       /* walk through all includes and check if it is our context */  
+                       i = ast_walk_context_includes(c, NULL);
+                       while (i) {
+                               /* is in this context included another on which we want to
+                                * remove?
+                                */
+                               if (!strcmp(context, ast_get_include_name(i))) {
+                                       /* yes, it's included, is matching our word too? */
+                                       if (!strncmp(ast_get_context_name(c),
+                                                       word, strlen(word))) {
+                                               /* check state for completion */
+                                               if (++which > state) {
+                                                       char *res = strdup(ast_get_context_name(c));
+                                                       free(dupline);
+                                                       ast_unlock_context(c);
+                                                       ast_unlock_contexts();
+                                                       return res;
+                                               }
+                                       }
+                                       break;
+                               }
+                               i = ast_walk_context_includes(c, i);
+                       }       
+                       ast_unlock_context(c);
+                       c = ast_walk_contexts(c);
+               }
+
+               free(dupline);
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       return NULL;
+}
+
+/*
+ * REMOVE EXTENSION command stuff
+ */
+static int handle_context_remove_extension(int fd, int argc, char *argv[])
+{
+       int removing_priority = 0;
+       char *exten, *context;
+
+       if (argc != 4 && argc != 3) return RESULT_SHOWUSAGE;
+
+       /*
+        * Priority input checking ...
+        */
+       if (argc == 4) {
+               char *c = argv[3];
+
+               /* check for digits in whole parameter for right priority ...
+                * why? because atoi (strtol) returns 0 if any characters in
+                * string and whole extension will be removed, it's not good
+                */
+               while (*c != '\0') {
+                       if (!isdigit(*c++)) {
+                               ast_cli(fd, "Invalid priority '%s'\n", argv[3]);
+                               return RESULT_FAILURE;
+                       }
+               }
+
+               removing_priority = atoi(argv[3]);
+
+               if (removing_priority == 0) {
+                       ast_cli(fd, "If you want to remove whole extension, please " \
+                               "omit priority argument\n");
+                       return RESULT_FAILURE;
+               }
+       }
+
+       /*
+        * Format exten@context checking ...
+        */
+       if (!(context = strchr(argv[2], (int)'@'))) {
+               ast_cli(fd, "First argument must be in exten@context format\n");
+               return RESULT_FAILURE;
+       }
+
+       *context++ = '\0';
+       exten = argv[2];
+       if ((!strlen(exten)) || (!(strlen(context)))) {
+               ast_cli(fd, "Missing extension or context name in second argument '%s@%s'\n",
+                       exten == NULL ? "?" : exten, context == NULL ? "?" : context);
+               return RESULT_FAILURE;
+       }
+
+       if (!ast_context_remove_extension(context, exten, removing_priority, registrar)) {
+               if (!removing_priority)
+                       ast_cli(fd, "Whole extension %s@%s removed\n",
+                               exten, context);
+               else
+                       ast_cli(fd, "Extension %s@%s with priority %d removed\n",
+                               exten, context, removing_priority);
+                       
+               return RESULT_SUCCESS;
+       }
+
+       ast_cli(fd, "Failed to remove extension %s@%s\n", exten, context);
+
+       return RESULT_FAILURE;
+}
+
+#define BROKEN_READLINE 1
+
+#ifdef BROKEN_READLINE
+/*
+ * There is one funny thing, when you have word like 300@ and you hit
+ * <tab>, you arguments will like as your word is '300 ', so it '@'
+ * characters acts sometimes as word delimiter and sometimes as a part
+ * of word
+ *
+ * This fix function, allocates new word variable and store here every
+ * time xxx@yyy always as one word and correct pos is set too
+ *
+ * It's ugly, I know, but I'm waiting for Mark suggestion if upper is
+ * bug or feature ...
+ */
+static int fix_complete_args(char *line, char **word, int *pos)
+{
+       char *_line, *_strsep_line, *_previous_word = NULL, *_word = NULL;
+       int words = 0;
+
+       _line = strdup(line);
+
+       _strsep_line = _line;
+       while (_strsep_line) {
+               _previous_word = _word;
+               _word = strsep(&_strsep_line, " ");
+
+               if (_word && strlen(_word)) words++;
+       }
+
+
+       if (_word || _previous_word) {
+               if (_word) {
+                       if (!strlen(_word)) words++;
+                       *word = strdup(_word);
+               } else
+                       *word = strdup(_previous_word);
+               *pos = words - 1;
+               free(_line);
+               return 0;
+       }
+
+       free(_line);
+       return -1;
+}
+#endif /* BROKEN_READLINE */
+
+static char *complete_context_remove_extension(char *line, char *word, int pos,
+       int state)
+{
+       char *ret;
+       int which = 0;
+
+#ifdef BROKEN_READLINE
+       /*
+        * Fix arguments, *word is a new allocated structure, REMEMBER to
+        * free *word when you want to return from this function ...
+        */
+       if (fix_complete_args(line, &word, &pos)) {
+               ast_log(LOG_ERROR, "Out of free memory\n");
+               return NULL;
+       }
+#endif
+
+       /*
+        * exten@context completion ... 
+        */
+       if (pos == 2) {
+               struct ast_context *c;
+               struct ast_exten *e;
+               char *context = NULL, *exten = NULL, *delim = NULL;
+
+               /* now, parse values from word = exten@context */
+               if ((delim = strchr(word, (int)'@'))) {
+                       /* check for duplicity ... */
+                       if (delim != strrchr(word, (int)'@')) {
+#ifdef BROKEN_READLINE
+                               free(word);
+#endif
+                               return NULL;
+                       }
+
+                       *delim = '\0';
+                       exten = strdup(word);
+                       context = strdup(delim + 1);
+                       *delim = '@';
+               } else {
+                       exten = strdup(word);
+               }
+#ifdef BROKEN_READLINE
+               free(word);
+#endif
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+                       free(context); free(exten);
+                       return NULL;
+               }
+
+               /* find our context ... */
+               c = ast_walk_contexts(NULL); 
+               while (c) {
+                       /* our context? */
+                       if ( (!context || !strlen(context)) ||                            /* if no input, all contexts ... */
+                                (context && !strncmp(ast_get_context_name(c),
+                                             context, strlen(context))) ) {                  /* if input, compare ... */
+                               /* try to complete extensions ... */
+                               e = ast_walk_context_extensions(c, NULL);
+                               while (e) {
+                                       /* our extension? */
+                                       if ( (!exten || !strlen(exten)) ||                           /* if not input, all extensions ... */
+                                                (exten && !strncmp(ast_get_extension_name(e), exten,
+                                                                   strlen(exten))) ) { /* if input, compare ... */
+                                               if (++which > state) {
+                                                       /* is there some context input? if not, throw back
+                                                        * exten@context, if yes throw back only context ...
+                                                        */
+                                                       if (!context) {
+                                                               ret = malloc(strlen(ast_get_extension_name(e)) +
+                                                                       strlen(ast_get_context_name(c)) + 2);
+                                                               if (ret)
+                                                                       sprintf(ret, "%s@%s", ast_get_extension_name(e),
+                                                                               ast_get_context_name(c));
+                                                       } else {
+                                                               ret = strdup(ast_get_context_name(c));
+                                                       }
+                                                       free(exten); free(context);
+
+                                                       ast_unlock_contexts();
+       
+                                                       return ret;
+                                               }
+                                       }
+                                       e = ast_walk_context_extensions(c, e);
+                               }
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+
+               free(exten); free(context);
+
+               return NULL;
+       }
+
+       /*
+        * Complete priority ...
+        */
+       if (pos == 3) {
+               char *delim, *exten, *context, *dupline, *duplinet, *ec;
+               struct ast_context *c;
+
+               dupline = strdup(line);
+               if (!dupline) {
+#ifdef BROKEN_READLINE
+                       free(word);
+#endif
+                       return NULL;
+               }
+               duplinet = dupline;
+
+               strsep(&duplinet, " "); /* skip 'remove' */
+               strsep(&duplinet, " "); /* skip 'extension */
+
+               if (!(ec = strsep(&duplinet, " "))) {
+                       free(dupline);
+#ifdef BROKEN_READLINE
+                       free(word);
+#endif
+                       return NULL;
+               }
+
+               /* wrong exten@context format? */
+               if (!(delim = strchr(ec, (int)'@')) ||
+                       (strchr(ec, (int)'@') != strrchr(ec, (int)'@'))) {
+#ifdef BROKEN_READLINE
+                       free(word);
+#endif
+                       free(dupline);
+                       return NULL;
+               }
+
+               /* check if there is exten and context too ... */
+               *delim = '\0';
+               if ((!strlen(ec)) || (!strlen(delim + 1))) {
+#ifdef BROKEN_READLINE
+                       free(word);
+#endif
+                       free(dupline);
+                       return NULL;
+               }
+
+               exten = strdup(ec);
+               context = strdup(delim + 1);
+               free(dupline);
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+#ifdef BROKEN_READLINE
+                       free(word);
+#endif
+                       free(exten); free(context);
+                       return NULL;
+               }
+
+               /* walk contexts */
+               c = ast_walk_contexts(NULL); 
+               while (c) {
+                       if (!strcmp(ast_get_context_name(c), context)) {
+                               struct ast_exten *e;
+
+                               /* walk extensions */
+                               free(context);
+                               e = ast_walk_context_extensions(c, NULL); 
+                               while (e) {
+                                       if (!strcmp(ast_get_extension_name(e), exten)) {
+                                               struct ast_exten *priority;
+                                               char buffer[10];
+                                       
+                                               free(exten);
+                                               priority = ast_walk_extension_priorities(e, NULL);
+                                               /* serve priorities */
+                                               do {
+                                                       snprintf(buffer, 10, "%u",
+                                                               ast_get_extension_priority(priority));
+                                                       if (!strncmp(word, buffer, strlen(word))) {
+                                                               if (++which > state) {
+#ifdef BROKEN_READLINE
+                                                                       free(word);
+#endif
+                                                                       ast_unlock_contexts();
+                                                                       return strdup(buffer);
+                                                               }
+                                                       }
+                                                       priority = ast_walk_extension_priorities(e,
+                                                               priority);
+                                               } while (priority);
+
+#ifdef BROKEN_READLINE
+                                               free(word);
+#endif
+                                               ast_unlock_contexts();
+                                               return NULL;                    
+                                       }
+                                       e = ast_walk_context_extensions(c, e);
+                               }
+#ifdef BROKEN_READLINE
+                               free(word);
+#endif
+                               free(exten);
+                               ast_unlock_contexts();
+                               return NULL;
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+#ifdef BROKEN_READLINE
+               free(word);
+#endif
+               free(exten); free(context);
+
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+#ifdef BROKEN_READLINE
+       free(word);
+#endif
+       return NULL; 
+}
+
+/*
+ * Include context ...
+ */
+static int handle_context_add_include(int fd, int argc, char *argv[])
+{
+       if (argc != 4) return RESULT_SHOWUSAGE;
+
+       /* third arg must be 'in' ... */
+       if (strcmp(argv[2], "in")) return RESULT_SHOWUSAGE;
+
+       if (ast_context_add_include(argv[3], argv[1], registrar)) {
+               switch (errno) {
+                       case ENOMEM:
+                               ast_cli(fd, "Out of memory for context addition\n"); break;
+
+                       case EBUSY:
+                               ast_cli(fd, "Failed to lock context(s) list, please try again later\n"); break;
+
+                       case EEXIST:
+                               ast_cli(fd, "Context '%s' already included in '%s' context\n",
+                                       argv[1], argv[3]); break;
+
+                       case ENODATA:
+                       case EINVAL:
+                               ast_cli(fd, "There is no existence of context '%s'\n",
+                                       errno == ENODATA ? argv[3] : argv[1]); break;
+
+                       default:
+                               ast_cli(fd, "Failed to include '%s' in '%s' context\n",
+                                       argv[1], argv[3]); break;
+               }
+               return RESULT_FAILURE;
+       }
+
+       /* show some info ... */
+       ast_cli(fd, "Context '%s' included in '%s' context\n",
+               argv[1], argv[3]);
+
+       return RESULT_SUCCESS;
+}
+
+static char *complete_context_add_include(char *line, char *word, int pos,
+    int state)
+{
+       struct ast_context *c;
+       int which = 0;
+
+       /* server context for inclusion ... */
+       if (pos == 1)
+       {
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+                       return NULL;
+               }
+
+               /* server all contexts */ 
+               c = ast_walk_contexts(NULL); 
+               while (c) {
+                       if ((!strlen(word) || 
+                                !strncmp(ast_get_context_name(c), word, strlen(word))) &&
+                               ++which > state)
+                       {
+                               char *context = strdup(ast_get_context_name(c));
+                               ast_unlock_contexts();
+                               return context;
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+       }
+
+       /* complete 'in' only if context exist ... */
+       if (pos == 2)
+       {
+               char *context, *dupline, *duplinet;
+
+               if (state != 0) return NULL;
+
+               /* parse context from line ... */
+               if (!(dupline = strdup(line))) {
+                       ast_log(LOG_ERROR, "Out of free memory\n");
+                       if (state == 0) return strdup("in");
+                       return NULL;
+               }
+
+               duplinet = dupline;
+
+               strsep(&duplinet, " ");
+               context = strsep(&duplinet, " ");
+               if (context) {
+                       struct ast_context *c;
+                       int context_existence = 0;
+
+                       /* check for context existence ... */
+                       if (ast_lock_contexts()) {
+                               ast_log(LOG_ERROR, "Failed to lock context list\n");
+                               free(dupline);
+                               /* our fault, we can't check, so complete 'in' ... */
+                               return strdup("in");
+                       }
+
+                       c = ast_walk_contexts(NULL);
+                       while (c && !context_existence) {
+                               if (!strcmp(context, ast_get_context_name(c))) {
+                                       context_existence = 1;
+                                       continue;
+                               }
+                               c = ast_walk_contexts(c);
+                       }
+
+                       /* if context exists, return 'into' ... */
+                       if (context_existence) {
+                               free(dupline);
+                               ast_unlock_contexts();
+                               return strdup("into");
+                       }
+
+                       ast_unlock_contexts();
+               }       
+
+               free(dupline);
+               return NULL;
+       }
+
+       /* serve context into which we include another context */
+       if (pos == 3)
+       {
+               char *context, *dupline, *duplinet, *in;
+               int context_existence = 0;
+
+               if (!(dupline = strdup(line))) {
+                       ast_log(LOG_ERROR, "Out of free memory\n");
+                       return NULL;
+               }
+
+               duplinet = dupline;
+
+               strsep(&duplinet, " "); /* skip 'include' */
+               context = strsep(&duplinet, " ");
+               in = strsep(&duplinet, " ");
+
+               /* given some context and third word is in? */
+               if (!strlen(context) || strcmp(in, "in")) {
+                       free(dupline);
+                       return NULL;
+               }
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock context list\n");
+                       free(dupline);
+                       return NULL;
+               }
+
+               /* check for context existence ... */
+               c = ast_walk_contexts(NULL);
+               while (c && !context_existence) {
+                       if (!strcmp(context, ast_get_context_name(c))) {
+                               context_existence = 1;
+                               continue;
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               if (!context_existence) {
+                       free(dupline);
+                       ast_unlock_contexts();
+                       return NULL;
+               }
+
+               /* go through all contexts ... */
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       /* must be different contexts ... */
+                       if (strcmp(context, ast_get_context_name(c))) {
+                               if (!ast_lock_context(c)) {
+                                       struct ast_include *i;
+                                       int included = 0;
+
+                                       /* check for duplicity inclusion ... */
+                                       i = ast_walk_context_includes(c, NULL);
+                                       while (i && !included) {
+                                               if (!strcmp(ast_get_include_name(i), context))
+                                                       included = 1;
+                                               i = ast_walk_context_includes(c, i);
+                                       }
+                                       ast_unlock_context(c);
+
+                                       /* not included yet, so show possibility ... */
+                                       if (!included &&
+                                               !strncmp(ast_get_context_name(c), word, strlen(word))){
+                                               
+                                               if (++which > state) {
+                                                       char *res = strdup(ast_get_context_name(c));
+                                                       free(dupline);
+                                                       ast_unlock_contexts();
+                                                       return res;
+                                               }
+                                       }       
+                               }
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+               free(dupline);
+               return NULL;
+       }
+
+       return NULL;
+}
+
+/*
+ * 'save dialplan' CLI command implementation functions ...
+ */
+static int handle_save_dialplan(int fd, int argc, char *argv[])
+{
+       char filename[256];
+       struct ast_context *c;
+       int context_header_written;
+       int incomplete = 0; /* incomplete config write? */
+       FILE *output;
+
+       if (! (static_config && !write_protect_config)) {
+               ast_cli(fd,
+                       "I can't save dialplan now, see '%s' example file.\n",
+                       config);
+               return RESULT_FAILURE;
+       }
+
+       if (argc != 2 && argc != 3) return RESULT_SHOWUSAGE;
+
+       if (ast_pthread_mutex_lock(&save_dialplan_lock)) {
+               ast_cli(fd,
+                       "Failed to lock dialplan saving (another proccess saving?)\n");
+               return RESULT_FAILURE;
+       }
+
+       /* have config path? */
+       if (argc == 3) {
+               /* is there extension.conf too? */
+               if (!strstr(argv[2], ".conf")) {
+                       /* no, only directory path, check for last '/' occurence */
+                       if (*(argv[2] + strlen(argv[2]) -1) == '/')
+                               snprintf(filename, sizeof(filename), "%s%s",
+                                       argv[2], config);
+                       else
+                               /* without config extensions.conf, add it */
+                               snprintf(filename, sizeof(filename), "%s/%s",
+                                       argv[2], config);
+               } else
+                       /* there is an .conf */
+                       snprintf(filename, sizeof(filename), argv[2]);
+       } else
+               /* no config file, default one */
+               snprintf(filename, sizeof(filename), "%s/%s",
+                       AST_CONFIG_DIR, config);
+
+       /* try to lock contexts list */
+       if (ast_lock_contexts()) {
+               ast_cli(fd, "Failed to lock contexts list\n");
+               ast_pthread_mutex_unlock(&save_dialplan_lock);
+               return RESULT_FAILURE;
+       }
+
+       /* create new file ... */
+       if (!(output = fopen(filename, "wt"))) {
+               ast_cli(fd, "Failed to create file '%s'\n",
+                       filename);
+               ast_unlock_contexts();
+               ast_pthread_mutex_unlock(&save_dialplan_lock);
+               return RESULT_FAILURE;
+       }
+
+       /* fireout general info */
+       fprintf(output, "[general]\nstatic=%s\nwriteprotect=%s\n\n",
+               static_config ? "yes" : "no",
+               write_protect_config ? "yes" : "no");
+
+       /* walk all contexts */
+       c = ast_walk_contexts(NULL);
+       while (c) {
+               context_header_written = 0;
+       
+               /* try to lock context and fireout all info */  
+               if (!ast_lock_context(c)) {
+                       struct ast_exten *e, *last_written_e = NULL;
+                       struct ast_include *i;
+                       struct ast_ignorepat *ip;
+
+                       /* registered by this module? */
+                       if (!strcmp(ast_get_context_registrar(c), registrar)) {
+                               fprintf(output, "[%s]\n", ast_get_context_name(c));
+                               context_header_written = 1;
+                       }
+
+                       /* walk extensions ... */
+                       e = ast_walk_context_extensions(c, NULL);
+                       while (e) {
+                               struct ast_exten *p;
+
+                               /* fireout priorities */
+                               p = ast_walk_extension_priorities(e, NULL);
+                               while (p) {
+                                       if (!strcmp(ast_get_extension_registrar(p),
+                                               registrar)) {
+                       
+                                               /* make empty line between different extensions */      
+                                               if (last_written_e != NULL &&
+                                                       strcmp(ast_get_extension_name(last_written_e),
+                                                               ast_get_extension_name(p)))
+                                                       fprintf(output, "\n");
+                                               last_written_e = p;
+                               
+                                               if (!context_header_written) {
+                                                       fprintf(output, "[%s]\n", ast_get_context_name(c));
+                                                       context_header_written = 1;
+                                               }
+
+                                               fprintf(output, "exten => %s,%d,%s,%s\n",
+                                                       ast_get_extension_name(p),
+                                                       ast_get_extension_priority(p),
+                                                       ast_get_extension_app(p),
+                                                       (char *)ast_get_extension_app_data(p));
+                                       }
+                                       p = ast_walk_extension_priorities(e, p);
+                               }
+
+                               e = ast_walk_context_extensions(c, e);
+                       }
+
+                       /* written any extensions? ok, write space between exten & inc */
+                       if (last_written_e) fprintf(output, "\n");
+
+                       /* walk through includes */
+                       i = ast_walk_context_includes(c, NULL);
+                       while (i) {
+                               if (!strcmp(ast_get_include_registrar(i), registrar)) {
+                                       if (!context_header_written) {
+                                               fprintf(output, "[%s]\n", ast_get_context_name(c));
+                                               context_header_written = 1;
+                                       }
+                                       fprintf(output, "include => %s\n",
+                                               ast_get_include_name(i));
+                               }
+                               i = ast_walk_context_includes(c, i);
+                       }
+
+                       if (ast_walk_context_includes(c, NULL))
+                               fprintf(output, "\n");
+
+                       /* fireout ignorepats ... */
+                       ip = ast_walk_context_ignorepats(c, NULL);
+                       while (ip) {
+                               if (!strcmp(ast_get_ignorepat_registrar(ip), registrar)) {
+                                       if (!context_header_written) {
+                                               fprintf(output, "[%s]\n", ast_get_context_name(c));
+                                               context_header_written = 1;
+                                       }
+
+                                       fprintf(output, "ignorepat => %s\n",
+                                               ast_get_ignorepat_name(ip));
+                               }
+                               ip = ast_walk_context_ignorepats(c, ip);
+                       }
+
+                       ast_unlock_context(c);
+               } else
+                       incomplete = 1;
+
+               c = ast_walk_contexts(c);
+       }       
+
+       ast_unlock_contexts();
+       ast_pthread_mutex_unlock(&save_dialplan_lock);
+       fclose(output);
+
+       if (incomplete) {
+               ast_cli(fd, "Saved dialplan is incomplete\n");
+               return RESULT_FAILURE;
+       }
+
+       ast_cli(fd, "Dialplane successfully saved into '%s'\n",
+               filename);
+       return RESULT_SUCCESS;
+}
+
+/*
+ * ADD EXTENSION command stuff
+ */
+static int handle_context_add_extension(int fd, int argc, char *argv[])
+{
+       char *whole_exten;
+       char *exten, *prior;
+       char *cidmatch, *app, *app_data;
+
+       /* check for arguments at first */
+       if (argc != 5 && argc != 6) return RESULT_SHOWUSAGE;
+       if (strcmp(argv[3], "into")) return RESULT_SHOWUSAGE;
+       if (argc == 6) if (strcmp(argv[5], "replace")) return RESULT_SHOWUSAGE;
+
+       whole_exten = argv[2];
+       exten           = strsep(&whole_exten,",");
+       if (strchr(exten, '/')) {
+               cidmatch = exten;
+               strsep(&cidmatch,"/");
+       } else {
+               cidmatch = NULL;
+       }
+       prior       = strsep(&whole_exten,",");
+       app         = strsep(&whole_exten,",");
+       app_data    = whole_exten;
+
+       if (!exten || !prior || !app || !app_data) return RESULT_SHOWUSAGE;
+
+       if (ast_add_extension(argv[4], argc == 6 ? 1 : 0, exten, atoi(prior), cidmatch, app,
+               (void *)strdup(app_data), free, registrar)) {
+               switch (errno) {
+                       case ENOMEM:
+                               ast_cli(fd, "Out of free memory\n"); break;
+
+                       case EBUSY:
+                               ast_cli(fd, "Failed to lock context(s) list, please try again later\n"); break;
+
+                       case ENODATA:
+                               ast_cli(fd, "No existence of '%s' context\n", argv[4]); break;
+
+                       case EEXIST:
+                               ast_cli(fd, "Extension %s@%s with priority %s already exists\n",
+                                       exten, argv[4], prior); break;
+
+                       default:
+                               ast_cli(fd, "Failed to add '%s,%s,%s,%s' extension into '%s' context\n",
+                                       exten, prior, app, app_data, argv[4]); break;
+               }
+               return RESULT_FAILURE;
+       }
+
+       if (argc == 6) 
+               ast_cli(fd, "Extension %s@%s (%s) replace by '%s,%s,%s,%s'\n",
+                       exten, argv[4], prior, exten, prior, app, app_data);
+       else
+               ast_cli(fd, "Extension '%s,%s,%s,%s' added into '%s' context\n",
+                       exten, prior, app, app_data, argv[4]);
+
+       return RESULT_SUCCESS;
+}
+
+/* add extension 6123,1,Dial,IAX/212.71.138.13/6123 into local */
+static char *complete_context_add_extension(char *line, char *word,
+       int pos, int state)
+{
+       int which = 0;
+
+       /* complete 'into' word ... */
+       if (pos == 3) {
+               if (state == 0) return strdup("into");
+               return NULL;
+       }
+
+       /* complete context */
+       if (pos == 4) {
+               struct ast_context *c;
+
+               /* try to lock contexts list ... */
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_WARNING, "Failed to lock contexts list\n");
+                       return NULL;
+               }
+
+               /* walk through all contexts */
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       /* matching context? */
+                       if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
+                               if (++which > state) {
+                                       char *res = strdup(ast_get_context_name(c));
+                                       ast_unlock_contexts();
+                                       return res;
+                               }
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       if (pos == 5) return state == 0 ? strdup("replace") : NULL;
+
+       return NULL;
+}
+
+/*
+ * IGNOREPAT CLI stuff
+ */
+static int handle_context_add_ignorepat(int fd, int argc, char *argv[])
+{
+       if (argc != 5) return RESULT_SHOWUSAGE;
+       if (strcmp(argv[3], "into")) return RESULT_SHOWUSAGE;
+
+       if (ast_context_add_ignorepat(argv[4], argv[2], registrar)) {
+               switch (errno) {
+                       case ENOMEM:
+                               ast_cli(fd, "Out of free memory\n"); break;
+
+                       case ENODATA:
+                               ast_cli(fd, "There is no existence of '%s' context\n", argv[4]);
+                               break;
+
+                       case EEXIST:
+                               ast_cli(fd, "Ignore pattern '%s' already included in '%s' context\n",
+                                       argv[2], argv[4]);
+                               break;
+
+                       case EBUSY:
+                               ast_cli(fd, "Failed to lock context(s) list, please, try again later\n");
+                               break;
+
+                       default:
+                               ast_cli(fd, "Failed to add ingore pattern '%s' into '%s' context\n",
+                                       argv[2], argv[4]);
+                               break;
+               }
+               return RESULT_FAILURE;
+       }
+
+       ast_cli(fd, "Ignore pattern '%s' added into '%s' context\n",
+               argv[2], argv[4]);
+       return RESULT_SUCCESS;
+}
+
+static char *complete_context_add_ignorepat(char *line, char *word,
+       int pos, int state)
+{
+       if (pos == 3) return state == 0 ? strdup("into") : NULL;
+
+       if (pos == 4) {
+               struct ast_context *c;
+               int which = 0;
+               char *dupline, *duplinet, *ignorepat = NULL;
+
+               dupline = strdup(line);
+               duplinet = dupline;
+
+               if (duplinet) {
+                       strsep(&duplinet, " "); /* skip 'add' */
+                       strsep(&duplinet, " "); /* skip 'ignorepat' */
+                       ignorepat = strsep(&duplinet, " ");
+               }
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_ERROR, "Failed to lock contexts list\n");
+                       return NULL;
+               }
+
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
+                               int serve_context = 1;
+                               if (ignorepat) {
+                                       if (!ast_lock_context(c)) {
+                                               struct ast_ignorepat *ip;
+                                               ip = ast_walk_context_ignorepats(c, NULL);
+                                               while (ip && serve_context) {
+                                                       if (!strcmp(ast_get_ignorepat_name(ip), ignorepat))
+                                                               serve_context = 0;
+                                                       ip = ast_walk_context_ignorepats(c, ip);
+                                               }
+                                               ast_unlock_context(c);
+                                       }
+                               }
+                               if (serve_context) {
+                                       if (++which > state) {
+                                               char *context = strdup(ast_get_context_name(c));
+                                               if (dupline) free(dupline);
+                                               ast_unlock_contexts();
+                                               return context;
+                                       }
+                               }
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               if (dupline) free(dupline);
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       return NULL;
+}
+
+static int handle_context_remove_ignorepat(int fd, int argc, char *argv[])
+{
+       if (argc != 5) return RESULT_SHOWUSAGE;
+       if (strcmp(argv[3], "from")) return RESULT_SHOWUSAGE;
+
+       if (ast_context_remove_ignorepat(argv[4], argv[2], registrar)) {
+               switch (errno) {
+                       case EBUSY:
+                               ast_cli(fd, "Failed to lock context(s) list, please try again later\n");
+                               break;
+
+                       case ENODATA:
+                               ast_cli(fd, "There is no existence of '%s' context\n", argv[4]);
+                               break;
+
+                       case EINVAL:
+                               ast_cli(fd, "There is no existence of '%s' ignore pattern in '%s' context\n",
+                                       argv[2], argv[4]);
+                               break;
+
+                       default:
+                               ast_cli(fd, "Failed to remove ignore pattern '%s' from '%s' context\n");
+                               break;
+               }
+               return RESULT_FAILURE;
+       }
+
+       ast_cli(fd, "Ignore pattern '%s' removed from '%s' context\n",
+               argv[2], argv[4]);
+       return RESULT_SUCCESS;
+}
+
+static char *complete_context_remove_ignorepat(char *line, char *word,
+       int pos, int state)
+{
+       struct ast_context *c;
+       int which = 0;
+
+       if (pos == 2) {
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_WARNING, "Failed to lock contexts list\n");
+                       return NULL;
+               }
+
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       if (!ast_lock_context(c)) {
+                               struct ast_ignorepat *ip;
+                       
+                               ip = ast_walk_context_ignorepats(c, NULL);
+                               while (ip) {
+                                       if (!strncmp(ast_get_ignorepat_name(ip), word, strlen(word))) {
+                                               if (which + 1 > state) {
+                                                       struct ast_context *cw;
+                                                       int already_served = 0;
+                                                       cw = ast_walk_contexts(NULL);
+                                                       while (cw && cw != c && !already_served) {
+                                                               if (!ast_lock_context(cw)) {
+                                                                       struct ast_ignorepat *ipw;
+                                                                       ipw = ast_walk_context_ignorepats(cw, NULL);
+                                                                       while (ipw) {
+                                                                               if (!strcmp(ast_get_ignorepat_name(ipw),
+                                                                                       ast_get_ignorepat_name(ip))) already_served = 1;
+                                                                               ipw = ast_walk_context_ignorepats(cw, ipw);
+                                                                       }
+                                                                       ast_unlock_context(cw);
+                                                               }
+                                                               cw = ast_walk_contexts(cw);
+                                                       }
+                                                       if (!already_served) {
+                                                               char *ret = strdup(ast_get_ignorepat_name(ip));
+                                                               ast_unlock_context(c);
+                                                               ast_unlock_contexts();
+                                                               return ret;
+                                                       }
+                                               } else
+                                                       which++;
+                                       }
+                                       ip = ast_walk_context_ignorepats(c, ip);
+                               }
+
+                               ast_unlock_context(c);
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               ast_unlock_contexts();
+               return NULL;
+       }
+       if (pos == 3) return state == 0 ? strdup("from") : NULL;
+
+       if (pos == 4) {
+               char *dupline, *duplinet, *ignorepat;
+
+               dupline = strdup(line);
+               if (!dupline) {
+                       ast_log(LOG_WARNING, "Out of free memory\n");
+                       return NULL;
+               }
+
+               duplinet = dupline;
+               strsep(&duplinet, " ");
+               strsep(&duplinet, " ");
+               ignorepat = strsep(&duplinet, " ");
+
+               if (!ignorepat) {
+                       free(dupline);
+                       return NULL;
+               }
+
+               if (ast_lock_contexts()) {
+                       ast_log(LOG_WARNING, "Failed to lock contexts list\n");
+                       free(dupline);
+                       return NULL;
+               }
+
+               c = ast_walk_contexts(NULL);
+               while (c) {
+                       if (!ast_lock_context(c)) {
+                               struct ast_ignorepat *ip;
+                               ip = ast_walk_context_ignorepats(c, NULL);
+                               while (ip) {
+                                       if (!strcmp(ast_get_ignorepat_name(ip), ignorepat)) {
+                                               if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
+                                                       if (++which > state) {
+                                                               char *ret = strdup(ast_get_context_name(c));
+                                                               free(dupline);
+                                                               ast_unlock_context(c);
+                                                               ast_unlock_contexts();
+                                                               return ret;
+                                                       }
+                                               }
+                                       }
+                                       ip = ast_walk_context_ignorepats(c, ip);
+                               }
+
+                               ast_unlock_context(c);
+                       }
+                       c = ast_walk_contexts(c);
+               }
+
+               free(dupline);
+               ast_unlock_contexts();
+               return NULL;
+       }
+
+       return NULL;
+}
+
+/*
+ * CLI entries for commands provided by this module
+ */
+static struct ast_cli_entry context_dont_include_cli =
+       { { "dont", "include", NULL }, handle_context_dont_include,
+               "Remove a specified include from context", context_dont_include_help,
+               complete_context_dont_include };
+
+static struct ast_cli_entry context_remove_extension_cli =
+       { { "remove", "extension", NULL }, handle_context_remove_extension,
+               "Remove a specified extension", context_remove_extension_help,
+               complete_context_remove_extension };
+
+static struct ast_cli_entry context_add_include_cli =
+       { { "include", "context", NULL }, handle_context_add_include,
+               "Include context in other context", context_add_include_help,
+               complete_context_add_include };
+
+static struct ast_cli_entry save_dialplan_cli =
+       { { "save", "dialplan", NULL }, handle_save_dialplan,
+               "Save dialplan", save_dialplan_help };
+
+static struct ast_cli_entry context_add_extension_cli =
+       { { "add", "extension", NULL }, handle_context_add_extension,
+               "Add new extension into context", context_add_extension_help,
+               complete_context_add_extension };
+
+static struct ast_cli_entry context_add_ignorepat_cli =
+       { { "add", "ignorepat", NULL }, handle_context_add_ignorepat,
+               "Add new ignore pattern", context_add_ignorepat_help,
+               complete_context_add_ignorepat };
+
+static struct ast_cli_entry context_remove_ignorepat_cli =
+       { { "remove", "ignorepat", NULL }, handle_context_remove_ignorepat,
+               "Remove ignore pattern from context", context_remove_ignorepat_help,
+               complete_context_remove_ignorepat };
+
+/*
+ * Standard module functions ...
+ */
 int unload_module(void)
 {
+       ast_cli_unregister(&context_add_extension_cli);
+       if (static_config && !write_protect_config)
+               ast_cli_unregister(&save_dialplan_cli);
+       ast_cli_unregister(&context_add_include_cli);
+       ast_cli_unregister(&context_dont_include_cli);
+       ast_cli_unregister(&context_remove_extension_cli);
+       ast_cli_unregister(&context_remove_ignorepat_cli);
+       ast_cli_unregister(&context_add_ignorepat_cli);
        ast_context_destroy(NULL, registrar);
        return 0;
 }
@@ -37,13 +1463,16 @@ static int pbx_load_module(void)
 {
        struct ast_config *cfg;
        struct ast_variable *v;
-       char *cxt, *ext, *pri, *appl, *data, *tc;
+       char *cxt, *ext, *pri, *appl, *data, *tc, *cidmatch;
        struct ast_context *con;
 
        cfg = ast_load(config);
        if (cfg) {
                /* Use existing config to populate the PBX table */
-               static_config = ast_true(ast_variable_retrieve(cfg, "general", "static"));
+               static_config = ast_true(ast_variable_retrieve(cfg, "general",
+                       "static"));
+               write_protect_config = ast_true(ast_variable_retrieve(cfg, "general",
+                       "writeprotect"));
                cxt = ast_category_browse(cfg, NULL);
                while(cxt) {
                        /* All categories but "general" are considered contexts */
@@ -66,15 +1495,30 @@ static int pbx_load_module(void)
                                                if (!appl)
                                                        appl="";
                                                data = strtok(NULL, ",");
+
+                                               strtok(ext, "/");
+                                               cidmatch = strtok(NULL, "/");
+
                                                if (!data)
                                                        data="";
-                                               if (ast_add_extension2(con, 0, ext, atoi(pri), appl, strdup(data), free, registrar)) {
+                                               if (ast_add_extension2(con, 0, ext, atoi(pri), cidmatch, appl, strdup(data), free, registrar)) {
                                                        ast_log(LOG_WARNING, "Unable to register extension at line %d\n", v->lineno);
                                                }
                                                free(tc);
                                        } else if(!strcasecmp(v->name, "include")) {
                                                if (ast_context_add_include2(con, v->value, registrar))
                                                        ast_log(LOG_WARNING, "Unable to include context '%s' in context '%s'\n", v->value, cxt);
+                                       } else if(!strcasecmp(v->name, "ignorepat")) {
+                                               if (ast_context_add_ignorepat2(con, v->value, registrar))
+                                                       ast_log(LOG_WARNING, "Unable to include ignorepat '%s' in context '%s'\n", v->value, cxt);
+                                       } else if (!strcasecmp(v->name, "switch")) {
+                                               tc = strdup(v->value);
+                                               appl = strtok(tc, "/");
+                                               data = strtok(NULL, "");
+                                               if (!data)
+                                                       data = "";
+                                               if (ast_context_add_switch2(con, appl, data, registrar))
+                                                       ast_log(LOG_WARNING, "Unable to include switch '%s' in context '%s'\n", v->value, cxt);
                                        }
                                        v = v->next;
                                }
@@ -88,13 +1532,24 @@ static int pbx_load_module(void)
 
 int load_module(void)
 {
-       return pbx_load_module();
+       if (pbx_load_module()) return -1;
+       ast_cli_register(&context_remove_extension_cli);
+       ast_cli_register(&context_dont_include_cli);
+       ast_cli_register(&context_add_include_cli);
+       if (static_config && !write_protect_config)
+               ast_cli_register(&save_dialplan_cli);
+       ast_cli_register(&context_add_extension_cli);
+       ast_cli_register(&context_add_ignorepat_cli);
+       ast_cli_register(&context_remove_ignorepat_cli);
+
+       return 0;
 }
 
 int reload(void)
 {
        ast_context_destroy(NULL, registrar);
-       load_module();
+       pbx_load_module();
        return 0;
 }