45953c6f5d309ffa224fdce0ee93d283e77e0680
[asterisk/asterisk.git] / pbx / pbx_config.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Populate and remember extensions from static config file
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <sys/types.h>
15 #include <asterisk/pbx.h>
16 #include <asterisk/config.h>
17 #include <asterisk/module.h>
18 #include <asterisk/logger.h>
19 #include <asterisk/cli.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <ctype.h>
24 #include <errno.h>
25 /* For where to put dynamic tables */
26 #include "../asterisk.h"
27 #include "../astconf.h"
28
29 #ifdef __AST_DEBUG_MALLOC
30 static void FREE(void *ptr)
31 {
32         free(ptr);
33 }
34 #else
35 #define FREE free
36 #endif
37
38 static char *dtext = "Text Extension Configuration";
39 static char *config = "extensions.conf";
40 static char *registrar = "pbx_config";
41
42 static int static_config = 0;
43 static int write_protect_config = 1;
44
45 static pthread_mutex_t save_dialplan_lock = AST_MUTEX_INITIALIZER;
46
47 /*
48  * Help for commands provided by this module ...
49  */
50 static char context_dont_include_help[] =
51 "Usage: dont include context in include\n"
52 "       Remove include from context.\n";
53
54 static char context_remove_extension_help[] =
55 "Usage: remove extension exten@context [priority]\n"
56 "       Remove whole extension from context. If priority is set, we are only\n"
57 "       removing extension with given priority.\n";
58
59 static char context_add_include_help[] =
60 "Usage: include context in context\n"
61 "       Include context in other context.\n";
62
63 static char save_dialplan_help[] =
64 "Usage: save dialplan [/path/to/extension/file]\n"
65 "       Save dialplan created by pbx_config module.\n"
66 "\n"
67 "Example: save dialplan                 (/etc/asterisk/extensions.conf)\n"
68 "         save dialplan /home/markster  (/home/markster/extensions.conf)\n";
69
70 static char context_add_extension_help[] =
71 "Usage: add extension <exten>,<priority>,<app>,<app-data> into <context>\n"
72 "       [replace]\n\n"
73 "       This command will add new extension into <context>. If there is an\n"
74 "       existence of extension with the same priority and last 'replace'\n"
75 "       arguments is given here we simply replace this extension.\n"
76 "\n"
77 "Example: add extension 6123,1,Dial,IAX/216.207.245.56/6123 into local\n"
78 "         Now, you can dial 6123 and talk to Markster :)\n";
79
80 static char context_add_ignorepat_help[] =
81 "Usage: add ignorepat <pattern> into <context>\n"
82 "       This command add new ignore pattern into context <context>\n"
83 "\n"
84 "Example: add ignorepat _3XX into local\n";
85
86 static char context_remove_ignorepat_help[] =
87 "Usage: remove ignorepat <pattern> from <context>\n"
88 "       This command remove ignore pattern from context <context>\n"
89 "\n"
90 "Example: remove ignorepat _3XX from local\n";
91
92 /*
93  * Implementation of functions provided by this module
94  */
95
96 /*
97  * REMOVE INCLUDE command stuff
98  */
99 static int handle_context_dont_include(int fd, int argc, char *argv[])
100 {
101         if (argc != 5) return RESULT_SHOWUSAGE;
102
103         if (strcmp(argv[3], "in")) return RESULT_SHOWUSAGE;
104
105         if (!ast_context_remove_include(argv[4], argv[2], registrar)) {
106                 ast_cli(fd, "We are not including '%s' in '%s' now\n",
107                         argv[2], argv[4]);
108                 return RESULT_SUCCESS;
109         }
110
111         ast_cli(fd, "Failed to remove '%s' include from '%s' context\n",
112                 argv[2], argv[4]);
113         return RESULT_FAILURE;
114 }
115
116 static char *complete_context_dont_include(char *line, char *word,
117         int pos, int state)
118 {
119         int which = 0;
120
121         /*
122          * Context completion ...
123          */
124         if (pos == 2) {
125                 struct ast_context *c;
126
127                 if (ast_lock_contexts()) {
128                         ast_log(LOG_ERROR, "Failed to lock context list\n");
129                         return NULL;
130                 }
131
132                 /* walk pbx_get_contexts ... */
133                 c = ast_walk_contexts(NULL); 
134                 while (c) {
135                         struct ast_include *i;
136
137                         if (ast_lock_context(c)) {
138                                 c = ast_walk_contexts(c);
139                                 continue;
140                         }
141
142                         i = ast_walk_context_includes(c, NULL);
143                         while (i) {
144                                 if (!strlen(word) ||
145                                         !strncmp(ast_get_include_name(i), word, strlen(word))) {
146                                         struct ast_context *nc;
147                                         int already_served = 0;
148
149                                         /* check if this include is already served or not */
150
151                                         /* go through all contexts again till we reach actuall
152                                          * context or already_served = 1
153                                          */
154                                         nc = ast_walk_contexts(NULL);
155                                         while (nc && nc != c && !already_served) {
156                                                 if (!ast_lock_context(nc)) {
157                                                         struct ast_include *ni;
158
159                                                         ni = ast_walk_context_includes(nc, NULL);
160                                                         while (ni && !already_served) {
161                                                                 if (!strcmp(ast_get_include_name(i),
162                                                                         ast_get_include_name(ni)))
163                                                                         already_served = 1;
164                                                                 ni = ast_walk_context_includes(nc, ni);
165                                                         }       
166                                                         
167                                                         ast_unlock_context(nc);
168                                                 }
169                                                 nc = ast_walk_contexts(nc);
170                                         }
171
172                                         if (!already_served) {
173                                                 if (++which > state) {
174                                                         char *res =
175                                                                 strdup(ast_get_include_name(i));
176                                                         ast_unlock_context(c);
177                                                         ast_unlock_contexts();
178                                                         return res;
179                                                 }
180                                         }
181                                 }
182                                 i = ast_walk_context_includes(c, i);
183                         }
184
185                         ast_unlock_context(c);
186                         c = ast_walk_contexts(c);
187                 }
188
189                 ast_unlock_contexts();
190                 return NULL;
191         }
192
193         /*
194          * 'in' completion ... (complete only if previous context is really
195          * included somewhere)
196          */
197         if (pos == 3) {
198                 struct ast_context *c;
199                 char *context, *dupline, *duplinet;
200
201                 if (state > 0) return NULL;
202
203                 /* take 'context' from line ... */
204                 if (!(dupline = strdup(line))) {
205                         ast_log(LOG_ERROR, "Out of free memory\n");
206                         return NULL;
207                 }
208
209                 duplinet = dupline;
210                 strsep(&duplinet, " "); /* skip 'dont' */
211                 strsep(&duplinet, " "); /* skip 'include' */
212                 context = strsep(&duplinet, " ");
213
214                 if (!context) {
215                         free(dupline);
216                         return NULL;
217                 }
218
219                 if (ast_lock_contexts()) {
220                         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
221                         free(dupline);
222                         return NULL;
223                 }
224
225                 /* go through all contexts and check if is included ... */
226                 c = ast_walk_contexts(NULL);
227                 while (c) {
228                         struct ast_include *i;
229                         if (ast_lock_context(c)) {
230                                 free(dupline);
231                                 ast_unlock_contexts();
232                                 return NULL;
233                         }
234
235                         i = ast_walk_context_includes(c, NULL);
236                         while (i) {
237                                 /* is it our context? */
238                                 if (!strcmp(ast_get_include_name(i), context)) {
239                                         /* yes, it is, context is really included, so
240                                          * complete "in" command
241                                          */
242                                         free(dupline);
243                                         ast_unlock_context(c);
244                                         ast_unlock_contexts();
245                                         return strdup("in");
246                                 }
247                                 i = ast_walk_context_includes(c, i);
248                         }
249                         ast_unlock_context(c);
250                         c = ast_walk_contexts(c);
251                 }
252                 free(dupline);
253                 ast_unlock_contexts();
254                 return NULL;
255         }
256
257         /*
258          * Context from which we removing include ... 
259          */
260         if (pos == 4) {
261                 struct ast_context *c;
262                 char *context, *dupline, *duplinet, *in;
263
264                 if (!(dupline = strdup(line))) {
265                         ast_log(LOG_ERROR, "Out of free memory\n");
266                         return NULL;
267                 }
268
269                 duplinet = dupline;
270
271                 strsep(&duplinet, " "); /* skip 'dont' */
272                 strsep(&duplinet, " "); /* skip 'include' */
273
274                 if (!(context = strsep(&duplinet, " "))) {
275                         free(dupline);
276                         return NULL;
277                 }
278
279                 /* third word must be in */
280                 in = strsep(&duplinet, " ");
281                 if (!in ||
282                         strcmp(in, "in")) {
283                         free(dupline);
284                         return NULL;
285                 }
286
287                 if (ast_lock_contexts()) {
288                         ast_log(LOG_ERROR, "Failed to lock context list\n");
289                         free(dupline);
290                         return NULL;
291                 }
292
293                 /* walk through all contexts ... */
294                 c = ast_walk_contexts(NULL);
295                 while (c) {
296                         struct ast_include *i;
297                         if (ast_lock_context(c)) {
298                                 free(dupline);
299                                 return NULL;
300                         }
301         
302                         /* walk through all includes and check if it is our context */  
303                         i = ast_walk_context_includes(c, NULL);
304                         while (i) {
305                                 /* is in this context included another on which we want to
306                                  * remove?
307                                  */
308                                 if (!strcmp(context, ast_get_include_name(i))) {
309                                         /* yes, it's included, is matching our word too? */
310                                         if (!strncmp(ast_get_context_name(c),
311                                                         word, strlen(word))) {
312                                                 /* check state for completion */
313                                                 if (++which > state) {
314                                                         char *res = strdup(ast_get_context_name(c));
315                                                         free(dupline);
316                                                         ast_unlock_context(c);
317                                                         ast_unlock_contexts();
318                                                         return res;
319                                                 }
320                                         }
321                                         break;
322                                 }
323                                 i = ast_walk_context_includes(c, i);
324                         }       
325                         ast_unlock_context(c);
326                         c = ast_walk_contexts(c);
327                 }
328
329                 free(dupline);
330                 ast_unlock_contexts();
331                 return NULL;
332         }
333
334         return NULL;
335 }
336
337 /*
338  * REMOVE EXTENSION command stuff
339  */
340 static int handle_context_remove_extension(int fd, int argc, char *argv[])
341 {
342         int removing_priority = 0;
343         char *exten, *context;
344
345         if (argc != 4 && argc != 3) return RESULT_SHOWUSAGE;
346
347         /*
348          * Priority input checking ...
349          */
350         if (argc == 4) {
351                 char *c = argv[3];
352
353                 /* check for digits in whole parameter for right priority ...
354                  * why? because atoi (strtol) returns 0 if any characters in
355                  * string and whole extension will be removed, it's not good
356                  */
357                 if (strcmp("hint", c)) {
358                     while (*c != '\0') {
359                         if (!isdigit(*c++)) {
360                                 ast_cli(fd, "Invalid priority '%s'\n", argv[3]);
361                                 return RESULT_FAILURE;
362                         }
363                     }
364                     removing_priority = atoi(argv[3]);
365                 } else
366                     removing_priority = PRIORITY_HINT;
367
368                 if (removing_priority == 0) {
369                         ast_cli(fd, "If you want to remove whole extension, please " \
370                                 "omit priority argument\n");
371                         return RESULT_FAILURE;
372                 }
373         }
374
375         /*
376          * Format exten@context checking ...
377          */
378         if (!(context = strchr(argv[2], (int)'@'))) {
379                 ast_cli(fd, "First argument must be in exten@context format\n");
380                 return RESULT_FAILURE;
381         }
382
383         *context++ = '\0';
384         exten = argv[2];
385         if ((!strlen(exten)) || (!(strlen(context)))) {
386                 ast_cli(fd, "Missing extension or context name in second argument '%s@%s'\n",
387                         exten == NULL ? "?" : exten, context == NULL ? "?" : context);
388                 return RESULT_FAILURE;
389         }
390
391         if (!ast_context_remove_extension(context, exten, removing_priority, registrar)) {
392                 if (!removing_priority)
393                         ast_cli(fd, "Whole extension %s@%s removed\n",
394                                 exten, context);
395                 else
396                         ast_cli(fd, "Extension %s@%s with priority %d removed\n",
397                                 exten, context, removing_priority);
398                         
399                 return RESULT_SUCCESS;
400         }
401
402         ast_cli(fd, "Failed to remove extension %s@%s\n", exten, context);
403
404         return RESULT_FAILURE;
405 }
406
407 #define BROKEN_READLINE 1
408
409 #ifdef BROKEN_READLINE
410 /*
411  * There is one funny thing, when you have word like 300@ and you hit
412  * <tab>, you arguments will like as your word is '300 ', so it '@'
413  * characters acts sometimes as word delimiter and sometimes as a part
414  * of word
415  *
416  * This fix function, allocates new word variable and store here every
417  * time xxx@yyy always as one word and correct pos is set too
418  *
419  * It's ugly, I know, but I'm waiting for Mark suggestion if upper is
420  * bug or feature ...
421  */
422 static int fix_complete_args(char *line, char **word, int *pos)
423 {
424         char *_line, *_strsep_line, *_previous_word = NULL, *_word = NULL;
425         int words = 0;
426
427         _line = strdup(line);
428
429         _strsep_line = _line;
430         while (_strsep_line) {
431                 _previous_word = _word;
432                 _word = strsep(&_strsep_line, " ");
433
434                 if (_word && strlen(_word)) words++;
435         }
436
437
438         if (_word || _previous_word) {
439                 if (_word) {
440                         if (!strlen(_word)) words++;
441                         *word = strdup(_word);
442                 } else
443                         *word = strdup(_previous_word);
444                 *pos = words - 1;
445                 free(_line);
446                 return 0;
447         }
448
449         free(_line);
450         return -1;
451 }
452 #endif /* BROKEN_READLINE */
453
454 static char *complete_context_remove_extension(char *line, char *word, int pos,
455         int state)
456 {
457         char *ret;
458         int which = 0;
459
460 #ifdef BROKEN_READLINE
461         /*
462          * Fix arguments, *word is a new allocated structure, REMEMBER to
463          * free *word when you want to return from this function ...
464          */
465         if (fix_complete_args(line, &word, &pos)) {
466                 ast_log(LOG_ERROR, "Out of free memory\n");
467                 return NULL;
468         }
469 #endif
470
471         /*
472          * exten@context completion ... 
473          */
474         if (pos == 2) {
475                 struct ast_context *c;
476                 struct ast_exten *e;
477                 char *context = NULL, *exten = NULL, *delim = NULL;
478
479                 /* now, parse values from word = exten@context */
480                 if ((delim = strchr(word, (int)'@'))) {
481                         /* check for duplicity ... */
482                         if (delim != strrchr(word, (int)'@')) {
483 #ifdef BROKEN_READLINE
484                                 free(word);
485 #endif
486                                 return NULL;
487                         }
488
489                         *delim = '\0';
490                         exten = strdup(word);
491                         context = strdup(delim + 1);
492                         *delim = '@';
493                 } else {
494                         exten = strdup(word);
495                 }
496 #ifdef BROKEN_READLINE
497                 free(word);
498 #endif
499
500                 if (ast_lock_contexts()) {
501                         ast_log(LOG_ERROR, "Failed to lock context list\n");
502                         free(context); free(exten);
503                         return NULL;
504                 }
505
506                 /* find our context ... */
507                 c = ast_walk_contexts(NULL); 
508                 while (c) {
509                         /* our context? */
510                         if ( (!context || !strlen(context)) ||                            /* if no input, all contexts ... */
511                                  (context && !strncmp(ast_get_context_name(c),
512                                               context, strlen(context))) ) {                  /* if input, compare ... */
513                                 /* try to complete extensions ... */
514                                 e = ast_walk_context_extensions(c, NULL);
515                                 while (e) {
516                                         /* our extension? */
517                                         if ( (!exten || !strlen(exten)) ||                           /* if not input, all extensions ... */
518                                                  (exten && !strncmp(ast_get_extension_name(e), exten,
519                                                                     strlen(exten))) ) { /* if input, compare ... */
520                                                 if (++which > state) {
521                                                         /* is there some context input? if not, throw back
522                                                          * exten@context, if yes throw back only context ...
523                                                          */
524                                                         if (!context) {
525                                                                 ret = malloc(strlen(ast_get_extension_name(e)) +
526                                                                         strlen(ast_get_context_name(c)) + 2);
527                                                                 if (ret)
528                                                                         sprintf(ret, "%s@%s", ast_get_extension_name(e),
529                                                                                 ast_get_context_name(c));
530                                                         } else {
531                                                                 ret = strdup(ast_get_context_name(c));
532                                                         }
533                                                         free(exten); free(context);
534
535                                                         ast_unlock_contexts();
536         
537                                                         return ret;
538                                                 }
539                                         }
540                                         e = ast_walk_context_extensions(c, e);
541                                 }
542                         }
543                         c = ast_walk_contexts(c);
544                 }
545
546                 ast_unlock_contexts();
547
548                 free(exten); free(context);
549
550                 return NULL;
551         }
552
553         /*
554          * Complete priority ...
555          */
556         if (pos == 3) {
557                 char *delim, *exten, *context, *dupline, *duplinet, *ec;
558                 struct ast_context *c;
559
560                 dupline = strdup(line);
561                 if (!dupline) {
562 #ifdef BROKEN_READLINE
563                         free(word);
564 #endif
565                         return NULL;
566                 }
567                 duplinet = dupline;
568
569                 strsep(&duplinet, " "); /* skip 'remove' */
570                 strsep(&duplinet, " "); /* skip 'extension */
571
572                 if (!(ec = strsep(&duplinet, " "))) {
573                         free(dupline);
574 #ifdef BROKEN_READLINE
575                         free(word);
576 #endif
577                         return NULL;
578                 }
579
580                 /* wrong exten@context format? */
581                 if (!(delim = strchr(ec, (int)'@')) ||
582                         (strchr(ec, (int)'@') != strrchr(ec, (int)'@'))) {
583 #ifdef BROKEN_READLINE
584                         free(word);
585 #endif
586                         free(dupline);
587                         return NULL;
588                 }
589
590                 /* check if there is exten and context too ... */
591                 *delim = '\0';
592                 if ((!strlen(ec)) || (!strlen(delim + 1))) {
593 #ifdef BROKEN_READLINE
594                         free(word);
595 #endif
596                         free(dupline);
597                         return NULL;
598                 }
599
600                 exten = strdup(ec);
601                 context = strdup(delim + 1);
602                 free(dupline);
603
604                 if (ast_lock_contexts()) {
605                         ast_log(LOG_ERROR, "Failed to lock context list\n");
606 #ifdef BROKEN_READLINE
607                         free(word);
608 #endif
609                         free(exten); free(context);
610                         return NULL;
611                 }
612
613                 /* walk contexts */
614                 c = ast_walk_contexts(NULL); 
615                 while (c) {
616                         if (!strcmp(ast_get_context_name(c), context)) {
617                                 struct ast_exten *e;
618
619                                 /* walk extensions */
620                                 free(context);
621                                 e = ast_walk_context_extensions(c, NULL); 
622                                 while (e) {
623                                         if (!strcmp(ast_get_extension_name(e), exten)) {
624                                                 struct ast_exten *priority;
625                                                 char buffer[10];
626                                         
627                                                 free(exten);
628                                                 priority = ast_walk_extension_priorities(e, NULL);
629                                                 /* serve priorities */
630                                                 do {
631                                                         snprintf(buffer, 10, "%u",
632                                                                 ast_get_extension_priority(priority));
633                                                         if (!strncmp(word, buffer, strlen(word))) {
634                                                                 if (++which > state) {
635 #ifdef BROKEN_READLINE
636                                                                         free(word);
637 #endif
638                                                                         ast_unlock_contexts();
639                                                                         return strdup(buffer);
640                                                                 }
641                                                         }
642                                                         priority = ast_walk_extension_priorities(e,
643                                                                 priority);
644                                                 } while (priority);
645
646 #ifdef BROKEN_READLINE
647                                                 free(word);
648 #endif
649                                                 ast_unlock_contexts();
650                                                 return NULL;                    
651                                         }
652                                         e = ast_walk_context_extensions(c, e);
653                                 }
654 #ifdef BROKEN_READLINE
655                                 free(word);
656 #endif
657                                 free(exten);
658                                 ast_unlock_contexts();
659                                 return NULL;
660                         }
661                         c = ast_walk_contexts(c);
662                 }
663
664 #ifdef BROKEN_READLINE
665                 free(word);
666 #endif
667                 free(exten); free(context);
668
669                 ast_unlock_contexts();
670                 return NULL;
671         }
672
673 #ifdef BROKEN_READLINE
674         free(word);
675 #endif
676         return NULL; 
677 }
678
679 /*
680  * Include context ...
681  */
682 static int handle_context_add_include(int fd, int argc, char *argv[])
683 {
684         if (argc != 4) return RESULT_SHOWUSAGE;
685
686         /* third arg must be 'in' ... */
687         if (strcmp(argv[2], "in")) return RESULT_SHOWUSAGE;
688
689         if (ast_context_add_include(argv[3], argv[1], registrar)) {
690                 switch (errno) {
691                         case ENOMEM:
692                                 ast_cli(fd, "Out of memory for context addition\n"); break;
693
694                         case EBUSY:
695                                 ast_cli(fd, "Failed to lock context(s) list, please try again later\n"); break;
696
697                         case EEXIST:
698                                 ast_cli(fd, "Context '%s' already included in '%s' context\n",
699                                         argv[1], argv[3]); break;
700
701                         case ENOENT:
702                         case EINVAL:
703                                 ast_cli(fd, "There is no existence of context '%s'\n",
704                                         errno == ENOENT ? argv[3] : argv[1]); break;
705
706                         default:
707                                 ast_cli(fd, "Failed to include '%s' in '%s' context\n",
708                                         argv[1], argv[3]); break;
709                 }
710                 return RESULT_FAILURE;
711         }
712
713         /* show some info ... */
714         ast_cli(fd, "Context '%s' included in '%s' context\n",
715                 argv[1], argv[3]);
716
717         return RESULT_SUCCESS;
718 }
719
720 static char *complete_context_add_include(char *line, char *word, int pos,
721     int state)
722 {
723         struct ast_context *c;
724         int which = 0;
725
726         /* server context for inclusion ... */
727         if (pos == 1)
728         {
729                 if (ast_lock_contexts()) {
730                         ast_log(LOG_ERROR, "Failed to lock context list\n");
731                         return NULL;
732                 }
733
734                 /* server all contexts */ 
735                 c = ast_walk_contexts(NULL); 
736                 while (c) {
737                         if ((!strlen(word) || 
738                                  !strncmp(ast_get_context_name(c), word, strlen(word))) &&
739                                 ++which > state)
740                         {
741                                 char *context = strdup(ast_get_context_name(c));
742                                 ast_unlock_contexts();
743                                 return context;
744                         }
745                         c = ast_walk_contexts(c);
746                 }
747
748                 ast_unlock_contexts();
749         }
750
751         /* complete 'in' only if context exist ... */
752         if (pos == 2)
753         {
754                 char *context, *dupline, *duplinet;
755
756                 if (state != 0) return NULL;
757
758                 /* parse context from line ... */
759                 if (!(dupline = strdup(line))) {
760                         ast_log(LOG_ERROR, "Out of free memory\n");
761                         if (state == 0) return strdup("in");
762                         return NULL;
763                 }
764
765                 duplinet = dupline;
766
767                 strsep(&duplinet, " ");
768                 context = strsep(&duplinet, " ");
769                 if (context) {
770                         struct ast_context *c;
771                         int context_existence = 0;
772
773                         /* check for context existence ... */
774                         if (ast_lock_contexts()) {
775                                 ast_log(LOG_ERROR, "Failed to lock context list\n");
776                                 free(dupline);
777                                 /* our fault, we can't check, so complete 'in' ... */
778                                 return strdup("in");
779                         }
780
781                         c = ast_walk_contexts(NULL);
782                         while (c && !context_existence) {
783                                 if (!strcmp(context, ast_get_context_name(c))) {
784                                         context_existence = 1;
785                                         continue;
786                                 }
787                                 c = ast_walk_contexts(c);
788                         }
789
790                         /* if context exists, return 'into' ... */
791                         if (context_existence) {
792                                 free(dupline);
793                                 ast_unlock_contexts();
794                                 return strdup("into");
795                         }
796
797                         ast_unlock_contexts();
798                 }       
799
800                 free(dupline);
801                 return NULL;
802         }
803
804         /* serve context into which we include another context */
805         if (pos == 3)
806         {
807                 char *context, *dupline, *duplinet, *in;
808                 int context_existence = 0;
809
810                 if (!(dupline = strdup(line))) {
811                         ast_log(LOG_ERROR, "Out of free memory\n");
812                         return NULL;
813                 }
814
815                 duplinet = dupline;
816
817                 strsep(&duplinet, " "); /* skip 'include' */
818                 context = strsep(&duplinet, " ");
819                 in = strsep(&duplinet, " ");
820
821                 /* given some context and third word is in? */
822                 if (!strlen(context) || strcmp(in, "in")) {
823                         free(dupline);
824                         return NULL;
825                 }
826
827                 if (ast_lock_contexts()) {
828                         ast_log(LOG_ERROR, "Failed to lock context list\n");
829                         free(dupline);
830                         return NULL;
831                 }
832
833                 /* check for context existence ... */
834                 c = ast_walk_contexts(NULL);
835                 while (c && !context_existence) {
836                         if (!strcmp(context, ast_get_context_name(c))) {
837                                 context_existence = 1;
838                                 continue;
839                         }
840                         c = ast_walk_contexts(c);
841                 }
842
843                 if (!context_existence) {
844                         free(dupline);
845                         ast_unlock_contexts();
846                         return NULL;
847                 }
848
849                 /* go through all contexts ... */
850                 c = ast_walk_contexts(NULL);
851                 while (c) {
852                         /* must be different contexts ... */
853                         if (strcmp(context, ast_get_context_name(c))) {
854                                 if (!ast_lock_context(c)) {
855                                         struct ast_include *i;
856                                         int included = 0;
857
858                                         /* check for duplicity inclusion ... */
859                                         i = ast_walk_context_includes(c, NULL);
860                                         while (i && !included) {
861                                                 if (!strcmp(ast_get_include_name(i), context))
862                                                         included = 1;
863                                                 i = ast_walk_context_includes(c, i);
864                                         }
865                                         ast_unlock_context(c);
866
867                                         /* not included yet, so show possibility ... */
868                                         if (!included &&
869                                                 !strncmp(ast_get_context_name(c), word, strlen(word))){
870                                                 
871                                                 if (++which > state) {
872                                                         char *res = strdup(ast_get_context_name(c));
873                                                         free(dupline);
874                                                         ast_unlock_contexts();
875                                                         return res;
876                                                 }
877                                         }       
878                                 }
879                         }
880                         c = ast_walk_contexts(c);
881                 }
882
883                 ast_unlock_contexts();
884                 free(dupline);
885                 return NULL;
886         }
887
888         return NULL;
889 }
890
891 /*
892  * 'save dialplan' CLI command implementation functions ...
893  */
894 static int handle_save_dialplan(int fd, int argc, char *argv[])
895 {
896         char filename[256];
897         struct ast_context *c;
898         int context_header_written;
899         int incomplete = 0; /* incomplete config write? */
900         FILE *output;
901
902         if (! (static_config && !write_protect_config)) {
903                 ast_cli(fd,
904                         "I can't save dialplan now, see '%s' example file.\n",
905                         config);
906                 return RESULT_FAILURE;
907         }
908
909         if (argc != 2 && argc != 3) return RESULT_SHOWUSAGE;
910
911         if (ast_pthread_mutex_lock(&save_dialplan_lock)) {
912                 ast_cli(fd,
913                         "Failed to lock dialplan saving (another proccess saving?)\n");
914                 return RESULT_FAILURE;
915         }
916
917         /* have config path? */
918         if (argc == 3) {
919                 /* is there extension.conf too? */
920                 if (!strstr(argv[2], ".conf")) {
921                         /* no, only directory path, check for last '/' occurence */
922                         if (*(argv[2] + strlen(argv[2]) -1) == '/')
923                                 snprintf(filename, sizeof(filename), "%s%s",
924                                         argv[2], config);
925                         else
926                                 /* without config extensions.conf, add it */
927                                 snprintf(filename, sizeof(filename), "%s/%s",
928                                         argv[2], config);
929                 } else
930                         /* there is an .conf */
931                         snprintf(filename, sizeof(filename), argv[2]);
932         } else
933                 /* no config file, default one */
934                 snprintf(filename, sizeof(filename), "%s/%s",
935                         (char *)ast_config_AST_CONFIG_DIR, config);
936
937         /* try to lock contexts list */
938         if (ast_lock_contexts()) {
939                 ast_cli(fd, "Failed to lock contexts list\n");
940                 ast_pthread_mutex_unlock(&save_dialplan_lock);
941                 return RESULT_FAILURE;
942         }
943
944         /* create new file ... */
945         if (!(output = fopen(filename, "wt"))) {
946                 ast_cli(fd, "Failed to create file '%s'\n",
947                         filename);
948                 ast_unlock_contexts();
949                 ast_pthread_mutex_unlock(&save_dialplan_lock);
950                 return RESULT_FAILURE;
951         }
952
953         /* fireout general info */
954         fprintf(output, "[general]\nstatic=%s\nwriteprotect=%s\n\n",
955                 static_config ? "yes" : "no",
956                 write_protect_config ? "yes" : "no");
957
958         /* walk all contexts */
959         c = ast_walk_contexts(NULL);
960         while (c) {
961                 context_header_written = 0;
962         
963                 /* try to lock context and fireout all info */  
964                 if (!ast_lock_context(c)) {
965                         struct ast_exten *e, *last_written_e = NULL;
966                         struct ast_include *i;
967                         struct ast_ignorepat *ip;
968
969                         /* registered by this module? */
970                         if (!strcmp(ast_get_context_registrar(c), registrar)) {
971                                 fprintf(output, "[%s]\n", ast_get_context_name(c));
972                                 context_header_written = 1;
973                         }
974
975                         /* walk extensions ... */
976                         e = ast_walk_context_extensions(c, NULL);
977                         while (e) {
978                                 struct ast_exten *p;
979
980                                 /* fireout priorities */
981                                 p = ast_walk_extension_priorities(e, NULL);
982                                 while (p) {
983                                         if (!strcmp(ast_get_extension_registrar(p),
984                                                 registrar)) {
985                         
986                                                 /* make empty line between different extensions */      
987                                                 if (last_written_e != NULL &&
988                                                         strcmp(ast_get_extension_name(last_written_e),
989                                                                 ast_get_extension_name(p)))
990                                                         fprintf(output, "\n");
991                                                 last_written_e = p;
992                                 
993                                                 if (!context_header_written) {
994                                                         fprintf(output, "[%s]\n", ast_get_context_name(c));
995                                                         context_header_written = 1;
996                                                 }
997
998                                                 if (ast_get_extension_priority(p)!=PRIORITY_HINT) {
999                                                         char *tempdata = NULL, *startdata;
1000                                                         tempdata = strdup((char *)ast_get_extension_app_data(p));
1001                                                         if (tempdata) {
1002                                                                 startdata = tempdata;
1003                                                                 while (*tempdata) {
1004                                                                         if (*tempdata == '|')
1005                                                                                 *tempdata = ',';
1006                                                                         tempdata++;
1007                                                                 }
1008                                                                 tempdata = startdata;
1009                                                         }
1010                                                         fprintf(output, "exten => %s,%d,%s(%s)\n",
1011                                                             ast_get_extension_name(p),
1012                                                             ast_get_extension_priority(p),
1013                                                             ast_get_extension_app(p),
1014                                                             tempdata);
1015                                                         if (tempdata)
1016                                                                 free(tempdata);
1017                                                 } else
1018                                                         fprintf(output, "exten => %s,hint,%s\n",
1019                                                             ast_get_extension_name(p),
1020                                                             ast_get_extension_app(p));
1021                                                 
1022                                         }
1023                                         p = ast_walk_extension_priorities(e, p);
1024                                 }
1025
1026                                 e = ast_walk_context_extensions(c, e);
1027                         }
1028
1029                         /* written any extensions? ok, write space between exten & inc */
1030                         if (last_written_e) fprintf(output, "\n");
1031
1032                         /* walk through includes */
1033                         i = ast_walk_context_includes(c, NULL);
1034                         while (i) {
1035                                 if (!strcmp(ast_get_include_registrar(i), registrar)) {
1036                                         if (!context_header_written) {
1037                                                 fprintf(output, "[%s]\n", ast_get_context_name(c));
1038                                                 context_header_written = 1;
1039                                         }
1040                                         fprintf(output, "include => %s\n",
1041                                                 ast_get_include_name(i));
1042                                 }
1043                                 i = ast_walk_context_includes(c, i);
1044                         }
1045
1046                         if (ast_walk_context_includes(c, NULL))
1047                                 fprintf(output, "\n");
1048
1049                         /* fireout ignorepats ... */
1050                         ip = ast_walk_context_ignorepats(c, NULL);
1051                         while (ip) {
1052                                 if (!strcmp(ast_get_ignorepat_registrar(ip), registrar)) {
1053                                         if (!context_header_written) {
1054                                                 fprintf(output, "[%s]\n", ast_get_context_name(c));
1055                                                 context_header_written = 1;
1056                                         }
1057
1058                                         fprintf(output, "ignorepat => %s\n",
1059                                                 ast_get_ignorepat_name(ip));
1060                                 }
1061                                 ip = ast_walk_context_ignorepats(c, ip);
1062                         }
1063
1064                         ast_unlock_context(c);
1065                 } else
1066                         incomplete = 1;
1067
1068                 c = ast_walk_contexts(c);
1069         }       
1070
1071         ast_unlock_contexts();
1072         ast_pthread_mutex_unlock(&save_dialplan_lock);
1073         fclose(output);
1074
1075         if (incomplete) {
1076                 ast_cli(fd, "Saved dialplan is incomplete\n");
1077                 return RESULT_FAILURE;
1078         }
1079
1080         ast_cli(fd, "Dialplane successfully saved into '%s'\n",
1081                 filename);
1082         return RESULT_SUCCESS;
1083 }
1084
1085 /*
1086  * ADD EXTENSION command stuff
1087  */
1088 static int handle_context_add_extension(int fd, int argc, char *argv[])
1089 {
1090         char *whole_exten;
1091         char *exten, *prior;
1092         int iprior = -2;
1093         char *cidmatch, *app, *app_data;
1094         char *start, *end;
1095
1096         /* check for arguments at first */
1097         if (argc != 5 && argc != 6) return RESULT_SHOWUSAGE;
1098         if (strcmp(argv[3], "into")) return RESULT_SHOWUSAGE;
1099         if (argc == 6) if (strcmp(argv[5], "replace")) return RESULT_SHOWUSAGE;
1100
1101         whole_exten = argv[2];
1102         exten           = strsep(&whole_exten,",");
1103         if (strchr(exten, '/')) {
1104                 cidmatch = exten;
1105                 strsep(&cidmatch,"/");
1106         } else {
1107                 cidmatch = NULL;
1108         }
1109         prior       = strsep(&whole_exten,",");
1110         if (prior) {
1111                 if (!strcmp(prior, "hint")) {
1112                         iprior = PRIORITY_HINT;
1113                 } else {
1114                         iprior = atoi(prior);
1115                 }
1116         }
1117         app         = strsep(&whole_exten,",");
1118         if (app && (start = strchr(app, '(')) && (end = strrchr(app, ')'))) {
1119                 *start = *end = '\0';
1120                 app_data = start + 1;
1121                 for (start = app_data; *start; start++)
1122                         if (*start == ',')
1123                                 *start = '|';
1124         } else
1125                 app_data    = whole_exten;
1126
1127         if (!exten || !prior || !app || (!app_data && iprior != PRIORITY_HINT)) return RESULT_SHOWUSAGE;
1128
1129         if (!app_data)
1130             app_data="";
1131         if (ast_add_extension(argv[4], argc == 6 ? 1 : 0, exten, iprior, cidmatch, app,
1132                 (void *)strdup(app_data), free, registrar)) {
1133                 switch (errno) {
1134                         case ENOMEM:
1135                                 ast_cli(fd, "Out of free memory\n"); break;
1136
1137                         case EBUSY:
1138                                 ast_cli(fd, "Failed to lock context(s) list, please try again later\n"); break;
1139
1140                         case ENOENT:
1141                                 ast_cli(fd, "No existence of '%s' context\n", argv[4]); break;
1142
1143                         case EEXIST:
1144                                 ast_cli(fd, "Extension %s@%s with priority %s already exists\n",
1145                                         exten, argv[4], prior); break;
1146
1147                         default:
1148                                 ast_cli(fd, "Failed to add '%s,%s,%s,%s' extension into '%s' context\n",
1149                                         exten, prior, app, app_data, argv[4]); break;
1150                 }
1151                 return RESULT_FAILURE;
1152         }
1153
1154         if (argc == 6) 
1155                 ast_cli(fd, "Extension %s@%s (%s) replace by '%s,%s,%s,%s'\n",
1156                         exten, argv[4], prior, exten, prior, app, app_data);
1157         else
1158                 ast_cli(fd, "Extension '%s,%s,%s,%s' added into '%s' context\n",
1159                         exten, prior, app, app_data, argv[4]);
1160
1161         return RESULT_SUCCESS;
1162 }
1163
1164 /* add extension 6123,1,Dial,IAX/212.71.138.13/6123 into local */
1165 static char *complete_context_add_extension(char *line, char *word,
1166         int pos, int state)
1167 {
1168         int which = 0;
1169
1170         /* complete 'into' word ... */
1171         if (pos == 3) {
1172                 if (state == 0) return strdup("into");
1173                 return NULL;
1174         }
1175
1176         /* complete context */
1177         if (pos == 4) {
1178                 struct ast_context *c;
1179
1180                 /* try to lock contexts list ... */
1181                 if (ast_lock_contexts()) {
1182                         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
1183                         return NULL;
1184                 }
1185
1186                 /* walk through all contexts */
1187                 c = ast_walk_contexts(NULL);
1188                 while (c) {
1189                         /* matching context? */
1190                         if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
1191                                 if (++which > state) {
1192                                         char *res = strdup(ast_get_context_name(c));
1193                                         ast_unlock_contexts();
1194                                         return res;
1195                                 }
1196                         }
1197                         c = ast_walk_contexts(c);
1198                 }
1199
1200                 ast_unlock_contexts();
1201                 return NULL;
1202         }
1203
1204         if (pos == 5) return state == 0 ? strdup("replace") : NULL;
1205
1206         return NULL;
1207 }
1208
1209 /*
1210  * IGNOREPAT CLI stuff
1211  */
1212 static int handle_context_add_ignorepat(int fd, int argc, char *argv[])
1213 {
1214         if (argc != 5) return RESULT_SHOWUSAGE;
1215         if (strcmp(argv[3], "into")) return RESULT_SHOWUSAGE;
1216
1217         if (ast_context_add_ignorepat(argv[4], argv[2], registrar)) {
1218                 switch (errno) {
1219                         case ENOMEM:
1220                                 ast_cli(fd, "Out of free memory\n"); break;
1221
1222                         case ENOENT:
1223                                 ast_cli(fd, "There is no existence of '%s' context\n", argv[4]);
1224                                 break;
1225
1226                         case EEXIST:
1227                                 ast_cli(fd, "Ignore pattern '%s' already included in '%s' context\n",
1228                                         argv[2], argv[4]);
1229                                 break;
1230
1231                         case EBUSY:
1232                                 ast_cli(fd, "Failed to lock context(s) list, please, try again later\n");
1233                                 break;
1234
1235                         default:
1236                                 ast_cli(fd, "Failed to add ingore pattern '%s' into '%s' context\n",
1237                                         argv[2], argv[4]);
1238                                 break;
1239                 }
1240                 return RESULT_FAILURE;
1241         }
1242
1243         ast_cli(fd, "Ignore pattern '%s' added into '%s' context\n",
1244                 argv[2], argv[4]);
1245         return RESULT_SUCCESS;
1246 }
1247
1248 static char *complete_context_add_ignorepat(char *line, char *word,
1249         int pos, int state)
1250 {
1251         if (pos == 3) return state == 0 ? strdup("into") : NULL;
1252
1253         if (pos == 4) {
1254                 struct ast_context *c;
1255                 int which = 0;
1256                 char *dupline, *duplinet, *ignorepat = NULL;
1257
1258                 dupline = strdup(line);
1259                 duplinet = dupline;
1260
1261                 if (duplinet) {
1262                         strsep(&duplinet, " "); /* skip 'add' */
1263                         strsep(&duplinet, " "); /* skip 'ignorepat' */
1264                         ignorepat = strsep(&duplinet, " ");
1265                 }
1266
1267                 if (ast_lock_contexts()) {
1268                         ast_log(LOG_ERROR, "Failed to lock contexts list\n");
1269                         return NULL;
1270                 }
1271
1272                 c = ast_walk_contexts(NULL);
1273                 while (c) {
1274                         if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
1275                                 int serve_context = 1;
1276                                 if (ignorepat) {
1277                                         if (!ast_lock_context(c)) {
1278                                                 struct ast_ignorepat *ip;
1279                                                 ip = ast_walk_context_ignorepats(c, NULL);
1280                                                 while (ip && serve_context) {
1281                                                         if (!strcmp(ast_get_ignorepat_name(ip), ignorepat))
1282                                                                 serve_context = 0;
1283                                                         ip = ast_walk_context_ignorepats(c, ip);
1284                                                 }
1285                                                 ast_unlock_context(c);
1286                                         }
1287                                 }
1288                                 if (serve_context) {
1289                                         if (++which > state) {
1290                                                 char *context = strdup(ast_get_context_name(c));
1291                                                 if (dupline) free(dupline);
1292                                                 ast_unlock_contexts();
1293                                                 return context;
1294                                         }
1295                                 }
1296                         }
1297                         c = ast_walk_contexts(c);
1298                 }
1299
1300                 if (dupline) free(dupline);
1301                 ast_unlock_contexts();
1302                 return NULL;
1303         }
1304
1305         return NULL;
1306 }
1307
1308 static int handle_context_remove_ignorepat(int fd, int argc, char *argv[])
1309 {
1310         if (argc != 5) return RESULT_SHOWUSAGE;
1311         if (strcmp(argv[3], "from")) return RESULT_SHOWUSAGE;
1312
1313         if (ast_context_remove_ignorepat(argv[4], argv[2], registrar)) {
1314                 switch (errno) {
1315                         case EBUSY:
1316                                 ast_cli(fd, "Failed to lock context(s) list, please try again later\n");
1317                                 break;
1318
1319                         case ENOENT:
1320                                 ast_cli(fd, "There is no existence of '%s' context\n", argv[4]);
1321                                 break;
1322
1323                         case EINVAL:
1324                                 ast_cli(fd, "There is no existence of '%s' ignore pattern in '%s' context\n",
1325                                         argv[2], argv[4]);
1326                                 break;
1327
1328                         default:
1329                                 ast_cli(fd, "Failed to remove ignore pattern '%s' from '%s' context\n");
1330                                 break;
1331                 }
1332                 return RESULT_FAILURE;
1333         }
1334
1335         ast_cli(fd, "Ignore pattern '%s' removed from '%s' context\n",
1336                 argv[2], argv[4]);
1337         return RESULT_SUCCESS;
1338 }
1339
1340 static char *complete_context_remove_ignorepat(char *line, char *word,
1341         int pos, int state)
1342 {
1343         struct ast_context *c;
1344         int which = 0;
1345
1346         if (pos == 2) {
1347                 if (ast_lock_contexts()) {
1348                         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
1349                         return NULL;
1350                 }
1351
1352                 c = ast_walk_contexts(NULL);
1353                 while (c) {
1354                         if (!ast_lock_context(c)) {
1355                                 struct ast_ignorepat *ip;
1356                         
1357                                 ip = ast_walk_context_ignorepats(c, NULL);
1358                                 while (ip) {
1359                                         if (!strncmp(ast_get_ignorepat_name(ip), word, strlen(word))) {
1360                                                 if (which + 1 > state) {
1361                                                         struct ast_context *cw;
1362                                                         int already_served = 0;
1363                                                         cw = ast_walk_contexts(NULL);
1364                                                         while (cw && cw != c && !already_served) {
1365                                                                 if (!ast_lock_context(cw)) {
1366                                                                         struct ast_ignorepat *ipw;
1367                                                                         ipw = ast_walk_context_ignorepats(cw, NULL);
1368                                                                         while (ipw) {
1369                                                                                 if (!strcmp(ast_get_ignorepat_name(ipw),
1370                                                                                         ast_get_ignorepat_name(ip))) already_served = 1;
1371                                                                                 ipw = ast_walk_context_ignorepats(cw, ipw);
1372                                                                         }
1373                                                                         ast_unlock_context(cw);
1374                                                                 }
1375                                                                 cw = ast_walk_contexts(cw);
1376                                                         }
1377                                                         if (!already_served) {
1378                                                                 char *ret = strdup(ast_get_ignorepat_name(ip));
1379                                                                 ast_unlock_context(c);
1380                                                                 ast_unlock_contexts();
1381                                                                 return ret;
1382                                                         }
1383                                                 } else
1384                                                         which++;
1385                                         }
1386                                         ip = ast_walk_context_ignorepats(c, ip);
1387                                 }
1388
1389                                 ast_unlock_context(c);
1390                         }
1391                         c = ast_walk_contexts(c);
1392                 }
1393
1394                 ast_unlock_contexts();
1395                 return NULL;
1396         }
1397  
1398         if (pos == 3) return state == 0 ? strdup("from") : NULL;
1399
1400         if (pos == 4) {
1401                 char *dupline, *duplinet, *ignorepat;
1402
1403                 dupline = strdup(line);
1404                 if (!dupline) {
1405                         ast_log(LOG_WARNING, "Out of free memory\n");
1406                         return NULL;
1407                 }
1408
1409                 duplinet = dupline;
1410                 strsep(&duplinet, " ");
1411                 strsep(&duplinet, " ");
1412                 ignorepat = strsep(&duplinet, " ");
1413
1414                 if (!ignorepat) {
1415                         free(dupline);
1416                         return NULL;
1417                 }
1418
1419                 if (ast_lock_contexts()) {
1420                         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
1421                         free(dupline);
1422                         return NULL;
1423                 }
1424
1425                 c = ast_walk_contexts(NULL);
1426                 while (c) {
1427                         if (!ast_lock_context(c)) {
1428                                 struct ast_ignorepat *ip;
1429                                 ip = ast_walk_context_ignorepats(c, NULL);
1430                                 while (ip) {
1431                                         if (!strcmp(ast_get_ignorepat_name(ip), ignorepat)) {
1432                                                 if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
1433                                                         if (++which > state) {
1434                                                                 char *ret = strdup(ast_get_context_name(c));
1435                                                                 free(dupline);
1436                                                                 ast_unlock_context(c);
1437                                                                 ast_unlock_contexts();
1438                                                                 return ret;
1439                                                         }
1440                                                 }
1441                                         }
1442                                         ip = ast_walk_context_ignorepats(c, ip);
1443                                 }
1444
1445                                 ast_unlock_context(c);
1446                         }
1447                         c = ast_walk_contexts(c);
1448                 }
1449
1450                 free(dupline);
1451                 ast_unlock_contexts();
1452                 return NULL;
1453         }
1454
1455         return NULL;
1456 }
1457
1458 /*
1459  * CLI entries for commands provided by this module
1460  */
1461 static struct ast_cli_entry context_dont_include_cli =
1462         { { "dont", "include", NULL }, handle_context_dont_include,
1463                 "Remove a specified include from context", context_dont_include_help,
1464                 complete_context_dont_include };
1465
1466 static struct ast_cli_entry context_remove_extension_cli =
1467         { { "remove", "extension", NULL }, handle_context_remove_extension,
1468                 "Remove a specified extension", context_remove_extension_help,
1469                 complete_context_remove_extension };
1470
1471 static struct ast_cli_entry context_add_include_cli =
1472         { { "include", "context", NULL }, handle_context_add_include,
1473                 "Include context in other context", context_add_include_help,
1474                 complete_context_add_include };
1475
1476 static struct ast_cli_entry save_dialplan_cli =
1477         { { "save", "dialplan", NULL }, handle_save_dialplan,
1478                 "Save dialplan", save_dialplan_help };
1479
1480 static struct ast_cli_entry context_add_extension_cli =
1481         { { "add", "extension", NULL }, handle_context_add_extension,
1482                 "Add new extension into context", context_add_extension_help,
1483                 complete_context_add_extension };
1484
1485 static struct ast_cli_entry context_add_ignorepat_cli =
1486         { { "add", "ignorepat", NULL }, handle_context_add_ignorepat,
1487                 "Add new ignore pattern", context_add_ignorepat_help,
1488                 complete_context_add_ignorepat };
1489
1490 static struct ast_cli_entry context_remove_ignorepat_cli =
1491         { { "remove", "ignorepat", NULL }, handle_context_remove_ignorepat,
1492                 "Remove ignore pattern from context", context_remove_ignorepat_help,
1493                 complete_context_remove_ignorepat };
1494
1495 /*
1496  * Standard module functions ...
1497  */
1498 int unload_module(void)
1499 {
1500         ast_cli_unregister(&context_add_extension_cli);
1501         if (static_config && !write_protect_config)
1502                 ast_cli_unregister(&save_dialplan_cli);
1503         ast_cli_unregister(&context_add_include_cli);
1504         ast_cli_unregister(&context_dont_include_cli);
1505         ast_cli_unregister(&context_remove_extension_cli);
1506         ast_cli_unregister(&context_remove_ignorepat_cli);
1507         ast_cli_unregister(&context_add_ignorepat_cli);
1508         ast_context_destroy(NULL, registrar);
1509         return 0;
1510 }
1511
1512 static int pbx_load_module(void)
1513 {
1514         struct ast_config *cfg;
1515         struct ast_variable *v;
1516         char *cxt, *ext, *pri, *appl, *data, *tc, *cidmatch;
1517         struct ast_context *con;
1518         char *start, *end;
1519
1520         cfg = ast_load(config);
1521         if (cfg) {
1522                 /* Use existing config to populate the PBX table */
1523                 static_config = ast_true(ast_variable_retrieve(cfg, "general",
1524                         "static"));
1525                 write_protect_config = ast_true(ast_variable_retrieve(cfg, "general",
1526                         "writeprotect"));
1527                 v = ast_variable_browse(cfg, "globals");
1528                 while(v) {
1529                         pbx_builtin_setvar_helper(NULL, v->name, v->value);
1530                         v = v->next;
1531                 }
1532                 cxt = ast_category_browse(cfg, NULL);
1533                 while(cxt) {
1534                         /* All categories but "general" are considered contexts */
1535                         if (!strcasecmp(cxt, "general") || !strcasecmp(cxt, "globals")) {
1536                                 cxt = ast_category_browse(cfg, cxt);
1537                                 continue;
1538                         }
1539                         if ((con=ast_context_create(cxt, registrar))) {
1540                                 v = ast_variable_browse(cfg, cxt);
1541                                 while(v) {
1542                                         if (!strcasecmp(v->name, "exten")) {
1543                                                 char *stringp=NULL;
1544                                                 int ipri = -2;
1545                                                 tc = strdup(v->value);
1546                                                 if(tc!=NULL){
1547                                                         stringp=tc;
1548                                                         ext = strsep(&stringp, ",");
1549                                                         if (!ext)
1550                                                                 ext="";
1551                                                         pri = strsep(&stringp, ",");
1552                                                         if (!pri)
1553                                                                 pri="";
1554                                                         if (!strcmp(pri,"hint"))
1555                                                                 ipri=PRIORITY_HINT;
1556                                                         else
1557                                                                 ipri=atoi(pri);
1558                                                         appl = stringp;
1559                                                         if (!appl)
1560                                                                 appl="";
1561                                                         if (!(start = strchr(appl, '('))) {
1562                                                                 if (stringp)
1563                                                                         appl = strsep(&stringp, ",");
1564                                                                 else
1565                                                                         appl = "";
1566                                                         }
1567                                                         if (start && (end = strrchr(appl, ')'))) {
1568                                                                 *start = *end = '\0';
1569                                                                 data = start + 1;
1570                                                                 for (start = data; *start; start++)
1571                                                                         if (*start == ',')
1572                                                                                 *start = '|';
1573                                                         } else if (stringp!=NULL && *stringp=='"') {
1574                                                                 stringp++;
1575                                                                 data = strsep(&stringp, "\"");
1576                                                                 stringp++;
1577                                                         } else {
1578                                                                 if (stringp)
1579                                                                         data = strsep(&stringp, ",");
1580                                                                 else
1581                                                                         data = "";
1582                                                         }
1583                                                         cidmatch = strchr(ext, '/');
1584                                                         if (cidmatch) {
1585                                                                 *cidmatch = '\0';
1586                                                                 cidmatch++;
1587                                                         }
1588                                                         stringp=ext;
1589                                                         strsep(&stringp, "/");
1590
1591                                                         if (!data)
1592                                                                 data="";
1593                                                         if (ast_add_extension2(con, 0, ext, ipri, cidmatch, appl, strdup(data), FREE, registrar)) {
1594                                                                 ast_log(LOG_WARNING, "Unable to register extension at line %d\n", v->lineno);
1595                                                         }
1596                                                         free(tc);
1597                                                 } else fprintf(stderr,"Error strdup returned NULL in %s\n",__PRETTY_FUNCTION__);
1598                                         } else if(!strcasecmp(v->name, "include")) {
1599                                                 if (ast_context_add_include2(con, v->value, registrar))
1600                                                         ast_log(LOG_WARNING, "Unable to include context '%s' in context '%s'\n", v->value, cxt);
1601                                         } else if(!strcasecmp(v->name, "ignorepat")) {
1602                                                 if (ast_context_add_ignorepat2(con, v->value, registrar))
1603                                                         ast_log(LOG_WARNING, "Unable to include ignorepat '%s' in context '%s'\n", v->value, cxt);
1604                                         } else if (!strcasecmp(v->name, "switch")) {
1605                                                 char *stringp=NULL;
1606                                                 tc = strdup(v->value);
1607                                                 stringp=tc;
1608                                                 appl = strsep(&stringp, "/");
1609                                                 data = strsep(&stringp, "");
1610                                                 if (!data)
1611                                                         data = "";
1612                                                 if (ast_context_add_switch2(con, appl, data, registrar))
1613                                                         ast_log(LOG_WARNING, "Unable to include switch '%s' in context '%s'\n", v->value, cxt);
1614                                         }
1615                                         v = v->next;
1616                                 }
1617                         }
1618                         cxt = ast_category_browse(cfg, cxt);
1619                 }
1620                 ast_destroy(cfg);
1621         }
1622         return 0;
1623 }
1624
1625 int load_module(void)
1626 {
1627         if (pbx_load_module()) return -1;
1628  
1629         ast_cli_register(&context_remove_extension_cli);
1630         ast_cli_register(&context_dont_include_cli);
1631         ast_cli_register(&context_add_include_cli);
1632         if (static_config && !write_protect_config)
1633                 ast_cli_register(&save_dialplan_cli);
1634         ast_cli_register(&context_add_extension_cli);
1635         ast_cli_register(&context_add_ignorepat_cli);
1636         ast_cli_register(&context_remove_ignorepat_cli);
1637
1638         return 0;
1639 }
1640
1641 int reload(void)
1642 {
1643         ast_context_destroy(NULL, registrar);
1644         /* For martin's global variables, don't clear them on reload */
1645 #if 0
1646         pbx_builtin_clear_globals();
1647 #endif  
1648         pbx_load_module();
1649         return 0;
1650 }
1651
1652 int usecount(void)
1653 {
1654         return 0;
1655 }
1656
1657 char *description(void)
1658 {
1659         return dtext;
1660 }
1661
1662 char *key(void)
1663 {
1664         return ASTERISK_GPL_KEY;
1665 }