| blob | 76d6ddb5f72ff9359edd5e946687894b45ae811d |
1 /*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 1999 - 2008, Digium, Inc.
5 *
6 * Mark Spencer <markster@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
19 /*! \file
20 *
21 * \brief Core PBX routines.
22 *
23 * \author Mark Spencer <markster@digium.com>
24 */
32 #include <ctype.h>
33 #include <time.h>
34 #include <sys/time.h>
35 #if defined(HAVE_SYSINFO)
36 #include <sys/sysinfo.h>
37 #endif
38 #if defined(SOLARIS)
39 #include <sys/loadavg.h>
40 #endif
69 /*!
70 * \note I M P O R T A N T :
71 *
72 * The speed of extension handling will likely be among the most important
73 * aspects of this PBX. The switching scheme as it exists right now isn't
74 * terribly bad (it's O(N+M), where N is the # of extensions and M is the avg #
75 * of priorities, but a constant search time here would be great ;-)
76 *
77 * A new algorithm to do searching based on a 'compiled' pattern tree is introduced
78 * here, and shows a fairly flat (constant) search time, even for over
79 * 10000 patterns.
80 *
81 * Also, using a hash table for context/priority name lookup can help prevent
82 * the find_extension routines from absorbing exponential cpu cycles as the number
83 * of contexts/priorities grow. I've previously tested find_extension with red-black trees,
84 * which have O(log2(n)) speed. Right now, I'm using hash tables, which do
85 * searches (ideally) in O(1) time. While these techniques do not yield much
86 * speed in small dialplans, they are worth the trouble in large dialplans.
87 *
88 */
90 #ifdef LOW_MEMORY
91 #define EXT_DATA_SIZE 256
92 #else
93 #define EXT_DATA_SIZE 8192
94 #endif
96 #define SWITCH_DATA_LENGTH 256
98 #define VAR_BUF_SIZE 4096
100 #define VAR_NORMAL 1
101 #define VAR_SOFTTRAN 2
102 #define VAR_HARDTRAN 3
104 #define BACKGROUND_SKIP (1 << 0)
105 #define BACKGROUND_NOANSWER (1 << 1)
106 #define BACKGROUND_MATCHEXTEN (1 << 2)
107 #define BACKGROUND_PLAYBACK (1 << 3)
114 });
116 #define WAITEXTEN_MOH (1 << 0)
117 #define WAITEXTEN_DIALTONE (1 << 1)
122 });
131 /*!
132 \brief ast_exten: An extension
133 The dialplan is saved as a linked list with each context
134 having it's own linked list of extensions - one item per
135 priority.
136 */
149 struct ast_hashtab *peer_table; /*!< Priorities list in hashtab form -- only on the head of the peer list */
150 struct ast_hashtab *peer_label_table; /*!< labeled priorities in the peers -- only on the head of the peer list */
154 };
156 /*! \brief ast_include: include= support in extensions.conf */
165 };
167 /*! \brief ast_sw: Switch statement in extensions.conf */
175 };
177 /*! \brief ast_ignorepat: Ignore patterns in dial plan */
182 };
184 /*! \brief match_char: forms a syntax tree for quick matching of extension patterns */
185 struct match_char
186 {
190 int specificity; /* simply the strlen of x, or 10 for X, 9 for Z, and 8 for N; and '.' and '!' will add 11 ? */
194 };
197 {
205 };
207 /*! \brief ast_context: An extension context */
211 struct ast_hashtab *root_table; /*!< For exact matches on the extensions in the pattern tree, and for traversals of the pattern_tree */
216 char *registrar; /*!< Registrar -- make sure you malloc this, as the registrar may have to survive module unloads */
217 int refcount; /*!< each module that would have created this context should inc/dec this as appropriate */
219 ast_mutex_t macrolock; /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */
221 };
224 /*! \brief ast_app: A registered application */
232 };
234 /*! \brief ast_state_cb: An extension state notify register item */
238 ast_state_cb_type callback;
240 };
242 /*! \brief Structure for dial plan hints
244 \note Hints are pointers from an extension in the dialplan to one or
245 more devices (tech/name)
246 - See \ref AstExtState
247 */
253 };
267 };
272 };
279 );
282 };
313 static void new_find_extension(const char *str, struct scoreboard *score, struct match_char *tree, int length, int spec, const char *callerid, const char *label, enum ext_match_t action);
315 static struct match_char *add_exten_to_pattern_tree(struct ast_context *con, struct ast_exten *e1, int findonly);
316 static struct match_char *add_pattern_node(struct ast_context *con, struct match_char *current, char *pattern, int is_pattern, int already, int specificity, struct match_char **parent);
330 /* a func for qsort to use to sort a char array */
332 {
339 else
341 }
343 /* labels, contexts are case sensitive priority numbers are ints */
345 {
350 /* assume context names are registered in a string table! */
352 }
355 {
361 }
363 /* but if they are the same, do the cidmatch values match? */
370 }
371 }
374 {
378 }
381 {
385 }
388 {
391 }
394 {
401 }
404 {
407 }
410 {
413 }
423 /*! \brief Subscription for device state change events */
432 /*! \brief Declaration of builtin applications */
439 {
440 /* These applications are built into the PBX core and do not
441 need separate modules */
449 },
460 "application will use when exiting to a dialed extension."
476 },
484 },
492 },
499 },
518 },
539 },
554 },
564 },
571 },
582 },
588 },
597 },
603 },
609 },
616 },
627 },
633 },
639 },
647 },
655 },
661 },
677 },
691 },
697 },
705 },
717 },
719 };
731 /* WARNING:
732 When holding this list's lock, do _not_ do anything that will cause conlock
733 to be taken, unless you _already_ hold it. The ast_merge_contexts_and_delete
734 function will take the locks in conlock/hints order, so any other
735 paths that require both locks must also take them in that order.
736 */
741 #ifdef CONTEXT_DEBUG
743 /* these routines are provided for doing run-time checks
744 on the extension structures, in case you are having
745 problems, this routine might help you localize where
746 the problem is occurring. It's kinda like a debug memory
747 allocator's arena checker... It'll eat up your cpu cycles!
748 but you'll see, if you call it in the right places,
749 right where your problems began...
750 */
752 /* you can break on the check_contexts_trouble()
753 routine in your debugger to stop at the moment
754 there's a problem */
758 {
761 }
767 {
774 /* try to find inconsistencies */
775 /* is every context in the context table in the context list and vice-versa ? */
780 }
788 }
789 }
791 ast_log(LOG_NOTICE,"Called from: %s:%d: Could not find the %s context in the linked list\n", file, line, c1->name);
793 }
794 }
799 ast_log(LOG_NOTICE,"Called from: %s:%d: Could not find the %s context in the hashtab\n", file, line, c2->name);
803 }
805 /* loop thru all contexts, and verify the exten structure compares to the
806 hashtab structure */
810 {
814 /* is every entry in the root list also in the root_table? */
816 {
825 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context records the exten %s (CID match: %s) but it is not in its root_table\n", file, line, c2->name, dummy_name, e1->cidmatch );
827 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context records the exten %s but it is not in its root_table\n", file, line, c2->name, dummy_name );
828 }
830 }
831 }
833 /* is every entry in the root_table also in the root list? */
836 ast_log(LOG_NOTICE,"Called from: %s:%d: No c2->root_table for context %s!\n", file, line, c2->name);
838 }
846 }
847 }
849 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context records the exten %s but it is not in its root_table\n", file, line, c2->name, e2->exten);
851 }
853 }
855 }
856 }
857 /* is every priority reflected in the peer_table at the head of the list? */
859 /* is every entry in the root list also in the root_table? */
860 /* are the per-extension peer_tables in the right place? */
867 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority has a peer_table entry, and shouldn't!\n", file, line, c2->name, e1->exten, e2->priority );
869 }
872 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority has a peer_label_table entry, and shouldn't!\n", file, line, c2->name, e1->exten, e2->priority );
874 }
877 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority doesn't have a peer_table!\n", file, line, c2->name, e1->exten, e2->priority );
879 }
882 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority doesn't have a peer_label_table!\n", file, line, c2->name, e1->exten, e2->priority );
884 }
889 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority is not reflected in the peer_table\n", file, line, c2->name, e1->exten, e2->priority );
891 }
892 }
897 }
899 /* is every entry in the peer_table also in the peer list? */
906 }
907 }
909 ast_log(LOG_NOTICE,"Called from: %s:%d: The %s context, %s exten, %d priority is not reflected in the peer list\n", file, line, c2->name, e1->exten, e2->priority );
911 }
912 }
914 }
915 }
917 }
918 #endif
920 /*
921 \note This function is special. It saves the stack so that no matter
922 how many times it is called, it returns to the same place */
926 {
935 /* save channel values */
946 /* restore channel values */
950 }
953 /*! Go no deeper than this through includes (not counting loops) */
954 #define AST_PBX_MAX_STACK 128
956 /*! \brief Find application handle in linked list
957 */
959 {
966 }
970 }
973 {
980 }
984 }
987 {
992 }
995 {
997 }
999 /* form a tree that fully describes all the patterns in a context's extensions
1000 * in this tree, a "node" represents an individual character or character set
1001 * meant to match the corresponding character in a dial string. The tree
1002 * consists of a series of match_char structs linked in a chain
1003 * via the alt_char pointers. More than one pattern can share the same parts of the
1004 * tree as other extensions with the same pattern to that point.
1005 * My first attempt to duplicate the finding of the 'best' pattern was flawed in that
1006 * I misunderstood the general algorithm. I thought that the 'best' pattern
1007 * was the one with lowest total score. This was not true. Thus, if you have
1008 * patterns "1XXXXX" and "X11111", you would be tempted to say that "X11111" is
1009 * the "best" match because it has fewer X's, and is therefore more specific,
1010 * but this is not how the old algorithm works. It sorts matching patterns
1011 * in a similar collating sequence as sorting alphabetic strings, from left to
1012 * right. Thus, "1XXXXX" comes before "X11111", and would be the "better" match,
1013 * because "1" is more specific than "X".
1014 * So, to accomodate this philosophy, I sort the tree branches along the alt_char
1015 * line so they are lowest to highest in specificity numbers. This way, as soon
1016 * as we encounter our first complete match, we automatically have the "best"
1017 * match and can stop the traversal immediately. Same for CANMATCH/MATCHMORE.
1018 * If anyone would like to resurrect the "wrong" pattern trie searching algorithm,
1019 * they are welcome to revert pbx to before 1 Apr 2008.
1020 * As an example, consider these 4 extensions:
1021 * (a) NXXNXXXXXX
1022 * (b) 307754XXXX
1023 * (c) fax
1024 * (d) NXXXXXXXXX
1025 *
1026 * In the above, between (a) and (d), (a) is a more specific pattern than (d), and would win over
1027 * most numbers. For all numbers beginning with 307754, (b) should always win.
1028 *
1029 * These pattern should form a (sorted) tree that looks like this:
1030 * { "3" } --next--> { "0" } --next--> { "7" } --next--> { "7" } --next--> { "5" } ... blah ... --> { "X" exten_match: (b) }
1031 * |
1032 * |alt
1033 * |
1034 * { "f" } --next--> { "a" } --next--> { "x" exten_match: (c) }
1035 * { "N" } --next--> { "X" } --next--> { "X" } --next--> { "N" } --next--> { "X" } ... blah ... --> { "X" exten_match: (a) }
1036 * | |
1037 * | |alt
1038 * |alt |
1039 * | { "X" } --next--> { "X" } ... blah ... --> { "X" exten_match: (d) }
1040 * |
1041 * NULL
1042 *
1043 * In the above, I could easily turn "N" into "23456789", but I think that a quick "if( *z >= '2' && *z <= '9' )" might take
1044 * fewer CPU cycles than a call to index("23456789",*z), where *z is the char to match...
1045 *
1046 * traversal is pretty simple: one routine merely traverses the alt list, and for each matching char in the pattern, it calls itself
1047 * on the corresponding next pointer, incrementing also the pointer of the string to be matched, and passing the total specificity and length.
1048 * We pass a pointer to a scoreboard down through, also.
1049 * The scoreboard isn't as necessary to the revised algorithm, but I kept it as a handy way to return the matched extension.
1050 * The first complete match ends the traversal, which should make this version of the pattern matcher faster
1051 * the previous. The same goes for "CANMATCH" or "MATCHMORE"; the first such match ends the traversal. In both
1052 * these cases, the reason we can stop immediately, is because the first pattern match found will be the "best"
1053 * according to the sort criteria.
1054 * Hope the limit on stack depth won't be a problem... this routine should
1055 * be pretty lean as far a stack usage goes. Any non-match terminates the recursion down a branch.
1056 *
1057 * In the above example, with the number "3077549999" as the pattern, the traversor could match extensions a, b and d. All are
1058 * of length 10; they have total specificities of 24580, 10246, and 25090, respectively, not that this matters
1059 * at all. (b) wins purely because the first character "3" is much more specific (lower specificity) than "N". I have
1060 * left the specificity totals in the code as an artifact; at some point, I will strip it out.
1061 *
1062 * Just how much time this algorithm might save over a plain linear traversal over all possible patterns is unknown,
1063 * because it's a function of how many extensions are stored in a context. With thousands of extensions, the speedup
1064 * can be very noticeable. The new matching algorithm can run several hundreds of times faster, if not a thousand or
1065 * more times faster in extreme cases.
1066 *
1067 * MatchCID patterns are also supported, and stored in the tree just as the extension pattern is. Thus, you
1068 * can have patterns in your CID field as well.
1069 *
1070 * */
1073 static void update_scoreboard(struct scoreboard *board, int length, int spec, struct ast_exten *exten, char last, const char *callerid, int deleted, struct match_char *node)
1074 {
1075 /* if this extension is marked as deleted, then skip this -- if it never shows
1076 on the scoreboard, it will never be found, nor will halt the traversal. */
1084 #ifdef NEED_DEBUG_HERE
1085 ast_log(LOG_NOTICE,"Scoreboarding (LONGER) %s, len=%d, score=%d\n", exten->exten, length, spec);
1086 #endif
1087 }
1090 {
1107 }
1116 }
1119 {
1136 }
1145 }
1148 {
1149 /* find the exten at the end of the rope */
1154 #ifdef NEED_DEBUG_HERE
1155 ast_log(LOG_NOTICE,"CanMatch_exten returns exten %s(%p)\n", node2->exten->exten, node2->exten);
1156 #endif
1158 }
1159 }
1160 #ifdef NEED_DEBUG_HERE
1162 #endif
1164 }
1167 {
1172 if (node && node->x[0] == '.' && !node->x[1]) /* dot and ! will ALWAYS be next match in a matchmore */
1188 }
1193 }
1195 }
1197 #ifdef DEBUG_THIS
1199 {
1201 {
1214 }
1215 }
1217 #endif
1219 static void new_find_extension(const char *str, struct scoreboard *score, struct match_char *tree, int length, int spec, const char *label, const char *callerid, enum ext_match_t action)
1220 {
1223 #ifdef DEBUG_THIS
1225 ast_log(LOG_NOTICE,"new_find_extension called with %s on (sub)tree %s action=%s\n", str, tree->x, action2str(action));
1226 else
1227 ast_log(LOG_NOTICE,"new_find_extension called with %s on (sub)tree NULL action=%s\n", str, action2str(action));
1228 #endif
1232 #define NEW_MATCHER_CHK_MATCH \
1233 if (p->exten && !(*(str+1))) { /* if a shorter pattern matches along the way, might as well report it */ \
1234 if (action == E_MATCH || action == E_SPAWN || action == E_FINDLABEL) { /* if in CANMATCH/MATCHMORE, don't let matches get in the way */ \
1235 update_scoreboard(score, length+1, spec+p->specificity, p->exten,0,callerid, p->deleted, p); \
1236 if (!p->deleted) { \
1237 if (action == E_FINDLABEL) { \
1238 if (ast_hashtab_lookup(score->exten->peer_label_table, &pattern)) { \
1240 return; \
1241 } \
1242 } else { \
1245 } \
1246 } \
1247 } \
1248 }
1250 #define NEW_MATCHER_RECURSE \
1254 new_find_extension(str+1, score, p->next_char, length+1, spec+p->specificity, callerid, label, action); \
1255 if (score->exten) { \
1258 } \
1259 } else { \
1260 new_find_extension("/", score, p->next_char, length+1, spec+p->specificity, callerid, label, action); \
1261 if (score->exten || ((action == E_CANMATCH || action == E_MATCHMORE) && score->canmatch)) { \
1265 } \
1266 } \
1267 } else if (p->next_char && !*(str+1)) { \
1268 score->canmatch = 1; \
1269 score->canmatch_exten = get_canmatch_exten(p); \
1270 if (action == E_CANMATCH || action == E_MATCHMORE) { \
1272 return; \
1273 } \
1274 }
1276 NEW_MATCHER_CHK_MATCH;
1277 NEW_MATCHER_RECURSE;
1278 }
1281 NEW_MATCHER_CHK_MATCH;
1282 NEW_MATCHER_RECURSE;
1283 }
1286 NEW_MATCHER_CHK_MATCH;
1287 NEW_MATCHER_RECURSE;
1288 }
1290 /* how many chars will the . match against? */
1294 str2++;
1295 i++;
1296 }
1298 update_scoreboard(score, length+i, spec+(i*p->specificity), p->exten, '.', callerid, p->deleted, p);
1302 }
1303 }
1305 new_find_extension("/", score, p->next_char, length+i, spec+(p->specificity*i), callerid, label, action);
1307 ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set--- %s\n", score->exten ? score->exten->exten : "NULL");
1309 }
1310 }
1312 /* how many chars will the . match against? */
1316 str2++;
1317 i++;
1318 }
1320 update_scoreboard(score, length+1, spec+(p->specificity*i), p->exten, '!', callerid, p->deleted, p);
1324 }
1325 }
1327 new_find_extension("/", score, p->next_char, length+i, spec+(p->specificity*i), callerid, label, action);
1329 ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set with '/' and '!'--- %s\n", score->exten ? score->exten->exten : "NULL");
1331 }
1332 }
1334 /* the pattern in the tree includes the cid match! */
1338 ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set with '/'--- %s\n", score->exten ? score->exten->exten : "NULL");
1340 }
1341 }
1344 NEW_MATCHER_CHK_MATCH;
1345 NEW_MATCHER_RECURSE;
1346 }
1347 }
1349 }
1351 /* the algorithm for forming the extension pattern tree is also a bit simple; you
1352 * traverse all the extensions in a context, and for each char of the extension,
1353 * you see if it exists in the tree; if it doesn't, you add it at the appropriate
1354 * spot. What more can I say? At the end of each exten, you cap it off by adding the
1355 * address of the extension involved. Duplicate patterns will be complained about.
1356 *
1357 * Ideally, this would be done for each context after it is created and fully
1358 * filled. It could be done as a finishing step after extensions.conf or .ael is
1359 * loaded, or it could be done when the first search is encountered. It should only
1360 * have to be done once, until the next unload or reload.
1361 *
1362 * I guess forming this pattern tree would be analogous to compiling a regex. Except
1363 * that a regex only handles 1 pattern, really. This trie holds any number
1364 * of patterns. Well, really, it **could** be considered a single pattern,
1365 * where the "|" (or) operator is allowed, I guess, in a way, sort of...
1366 */
1369 {
1376 if (!strcmp(pat, t->x)) /* uh, we may want to sort exploded [] contents to make matching easy */
1378 }
1381 }
1383 /* The first arg is the location of the tree ptr, or the
1384 address of the next_char ptr in the node, so we can mess
1385 with it, if we need to insert at the beginning of the list */
1387 static void insert_in_next_chars_alt_char_list(struct match_char **parent_ptr, struct match_char *node)
1388 {
1391 /* insert node into the tree at "current", so the alt_char list from current is
1392 sorted in increasing value as you go to the leaves */
1397 /* insert at head */
1407 }
1409 }
1411 {
1413 }
1414 }
1415 }
1416 }
1420 static struct match_char *add_pattern_node(struct ast_context *con, struct match_char *current, char *pattern, int is_pattern, int already, int specificity, struct match_char **nextcharptr)
1421 {
1430 }
1432 /* the specificity scores are the same as used in the old
1433 pattern matcher. */
1445 else
1455 }
1456 }
1459 }
1461 static struct match_char *add_exten_to_pattern_tree(struct ast_context *con, struct ast_exten *e1, int findonly)
1462 {
1478 ast_log(LOG_ERROR,"The pattern %s/%s is too big to deal with: it will be ignored! Disaster!\n", e1->exten, e1->cidmatch);
1480 }
1481 #ifdef NEED_DEBUG
1482 ast_log(LOG_DEBUG,"Adding exten %s%c%s to tree\n", s1, e1->matchcid? '/':' ', e1->matchcid? e1->cidmatch : "");
1483 #endif
1490 s1++;
1491 }
1511 }
1517 }
1521 }
1522 }
1524 /* sort the characters */
1533 s1++;
1543 }
1545 }
1548 }
1551 if (!(*(s1+1))) { /* if this is the end of the pattern, but not the end of the tree, then mark this node with the exten...
1552 a shorter pattern might win if the longer one doesn't match */
1555 }
1566 m1 = add_pattern_node(con, m1, buf, pattern, already,specif, m0); /* m1 is the node just added */
1568 }
1573 }
1576 }
1578 }
1580 }
1583 {
1586 #ifdef NEED_DEBUG
1591 ast_log(LOG_DEBUG,"This tree has %d objects in %d bucket lists, longest list=%d objects, and has resized %d times\n",
1593 #endif
1598 else
1600 }
1602 }
1604 static void destroy_pattern_tree(struct match_char *pattern_tree) /* pattern tree is a simple binary tree, sort of, so the proper way to destroy it is... recursively! */
1605 {
1606 /* destroy all the alternates */
1610 }
1611 /* destroy all the nexts */
1615 }
1620 }
1622 /*
1623 * Special characters used in patterns:
1624 * '_' underscore is the leading character of a pattern.
1625 * In other position it is treated as a regular char.
1626 * ' ' '-' space and '-' are separator and ignored.
1627 * . one or more of any character. Only allowed at the end of
1628 * a pattern.
1629 * ! zero or more of anything. Also impacts the result of CANMATCH
1630 * and MATCHMORE. Only allowed at the end of a pattern.
1631 * In the core routine, ! causes a match with a return code of 2.
1632 * In turn, depending on the search mode: (XXX check if it is implemented)
1633 * - E_MATCH retuns 1 (does match)
1634 * - E_MATCHMORE returns 0 (no match)
1635 * - E_CANMATCH returns 1 (does match)
1636 *
1637 * / should not appear as it is considered the separator of the CID info.
1638 * XXX at the moment we may stop on this char.
1639 *
1640 * X Z N match ranges 0-9, 1-9, 2-9 respectively.
1641 * [ denotes the start of a set of character. Everything inside
1642 * is considered literally. We can have ranges a-d and individual
1643 * characters. A '[' and '-' can be considered literally if they
1644 * are just before ']'.
1645 * XXX currently there is no way to specify ']' in a range, nor \ is
1646 * considered specially.
1647 *
1648 * When we compare a pattern with a specific extension, all characters in the extension
1649 * itself are considered literally with the only exception of '-' which is considered
1650 * as a separator and thus ignored.
1651 * XXX do we want to consider space as a separator as well ?
1652 * XXX do we want to consider the separators in non-patterns as well ?
1653 */
1655 /*!
1656 * \brief helper functions to sort extensions and patterns in the desired way,
1657 * so that more specific patterns appear first.
1658 *
1659 * ext_cmp1 compares individual characters (or sets of), returning
1660 * an int where bits 0-7 are the ASCII code of the first char in the set,
1661 * while bit 8-15 are the cardinality of the set minus 1.
1662 * This way more specific patterns (smaller cardinality) appear first.
1663 * Wildcards have a special value, so that we can directly compare them to
1664 * sets by subtracting the two values. In particular:
1665 * 0x000xx one character, xx
1666 * 0x0yyxx yy character set starting with xx
1667 * 0x10000 '.' (one or more of anything)
1668 * 0x20000 '!' (zero or more of anything)
1669 * 0x30000 NUL (end of string)
1670 * 0x40000 error in set.
1671 * The pointer to the string is advanced according to needs.
1672 * NOTES:
1673 * 1. the empty set is equivalent to NUL.
1674 * 2. given that a full set has always 0 as the first element,
1675 * we could encode the special cases as 0xffXX where XX
1676 * is 1, 2, 3, 4 as used above.
1677 */
1679 {
1684 /* load, sign extend and advance pointer until we find
1685 * a valid character.
1686 */
1690 /* always return unless we have a set of chars */
1716 }
1717 /* locate end of set */
1723 }
1741 }
1742 }
1745 }
1747 /*!
1748 * \brief the full routine to compare extensions in rules.
1749 */
1751 {
1752 /* make sure non-patterns come first.
1753 * If a is not a pattern, it either comes first or
1754 * we use strcmp to compare the strings.
1755 */
1761 /* Now we know a is a pattern; if b is not, a comes first */
1766 #endif
1767 /* ok we need full pattern sorting routine */
1772 else
1774 }
1777 {
1779 }
1781 /*!
1782 * \internal
1783 * \brief used ast_extension_{match|close}
1784 * mode is as follows:
1785 * E_MATCH success only on exact match
1786 * E_MATCHMORE success only on partial match (i.e. leftover digits in pattern)
1787 * E_CANMATCH either of the above.
1788 * \retval 0 on no-match
1789 * \retval 1 on match
1790 * \retval 2 on early match.
1791 */
1794 {
1797 #ifdef NEED_DEBUG_HERE
1799 #endif
1801 if ( (mode == E_MATCH) && (pattern[0] == '_') && (!strcasecmp(pattern,data)) ) { /* note: if this test is left out, then _x. will not match _x. !!! */
1802 #ifdef NEED_DEBUG_HERE
1804 #endif
1806 }
1812 #ifdef NEED_DEBUG_HERE
1814 #endif
1816 }
1817 /* depending on the mode, accept full or partial match or both */
1819 #ifdef NEED_DEBUG_HERE
1821 #endif
1823 }
1825 #ifdef NEED_DEBUG_HERE
1827 #endif
1830 #ifdef NEED_DEBUG_HERE
1831 ast_log(LOG_NOTICE,"return (0) when ld(%d) > 0 && pattern(%s) != data(%s)\n", ld, pattern, data);
1832 #endif
1834 }
1835 }
1837 /*
1838 * XXX below we stop at '/' which is a separator for the CID info. However we should
1839 * not store '/' in the pattern at all. When we insure it, we can remove the checks.
1840 */
1845 data++;
1847 }
1854 }
1862 }
1865 }
1867 #ifdef NEED_DEBUG_HERE
1869 #endif
1871 }
1876 #ifdef NEED_DEBUG_HERE
1878 #endif
1880 }
1884 #ifdef NEED_DEBUG_HERE
1886 #endif
1888 }
1892 #ifdef NEED_DEBUG_HERE
1894 #endif
1896 }
1899 #ifdef NEED_DEBUG_HERE
1901 #endif
1904 #ifdef NEED_DEBUG_HERE
1906 #endif
1914 #ifdef NEED_DEBUG_HERE
1916 #endif
1918 }
1920 }
1921 data++;
1922 pattern++;
1923 }
1925 #ifdef NEED_DEBUG_HERE
1927 #endif
1929 }
1931 /*
1932 * match so far, but ran off the end of the data.
1933 * Depending on what is next, determine match or not.
1934 */
1936 #ifdef NEED_DEBUG_HERE
1938 #endif
1941 #ifdef NEED_DEBUG_HERE
1943 #endif
1946 #ifdef NEED_DEBUG_HERE
1948 #endif
1950 }
1951 }
1953 /*
1954 * Wrapper around _extension_match_core() to do performance measurement
1955 * using the profiling code.
1956 */
1958 {
1967 }
1970 {
1972 }
1975 {
1979 }
1982 {
1983 ast_rwlock_t lock;
1993 ast_mutex_t macrolock;
1995 };
1998 {
2009 }
2010 }
2013 }
2015 #define STATUS_NO_CONTEXT 1
2016 #define STATUS_NO_EXTENSION 2
2017 #define STATUS_NO_PRIORITY 3
2018 #define STATUS_NO_LABEL 4
2019 #define STATUS_SUCCESS 5
2022 {
2023 /* If the Caller*ID pattern is empty, then we're matching NO Caller*ID, so
2024 failing to get a number should count as a match, otherwise not */
2030 }
2036 {
2048 #ifdef NEED_DEBUG_HERE
2049 ast_log(LOG_NOTICE,"Looking for cont/ext/prio/label/action = %s/%s/%d/%s/%d\n", context, exten, priority, label, (int)action);
2050 #endif
2055 /* Initialize status if appropriate */
2064 }
2066 /* Check first to see if we've already been checked */
2070 }
2078 #ifdef NOTNOW
2083 }
2084 #endif
2088 }
2093 /* Do a search for matching extension */
2100 {
2102 #ifdef NEED_DEBUG
2105 #endif
2106 }
2107 #ifdef NEED_DEBUG
2110 #endif
2126 }
2130 }
2136 /* Substitute variables now */
2141 }
2143 /* equivalent of extension_match_core() at the switch level */
2155 }
2159 }
2160 }
2165 /* XXX keep status = STATUS_NO_CONTEXT ? */
2167 }
2168 }
2176 /* We match an extension ending in '!'.
2177 * The decision in this case is final and is NULL (no match).
2178 */
2179 #ifdef NEED_DEBUG_HERE
2181 #endif
2183 }
2187 #ifdef NEED_DEBUG_HERE
2189 #endif
2191 }
2197 #ifdef NEED_DEBUG_HERE
2199 #endif
2202 #ifdef NEED_DEBUG_HERE
2203 ast_log(LOG_NOTICE,"Returning CANMATCH/MATCHMORE canmatchmatch exten %s(%p)\n", score.canmatch_exten->exten, score.canmatch_exten);
2204 #endif
2207 #ifdef NEED_DEBUG_HERE
2209 #endif
2210 }
2211 }
2213 }
2214 #ifdef NEED_DEBUG_HERE
2216 #endif
2218 }
2221 /* found entry, now look for the right priority */
2231 }
2235 #ifdef NEED_DEBUG_HERE
2237 #endif
2239 }
2240 }
2243 /* scan the list trying to match extension and CID */
2247 /* 0 on fail, 1 on match, 2 on earlymatch */
2252 /* We match an extension ending in '!'.
2253 * The decision in this case is final and is NULL (no match).
2254 */
2256 }
2257 /* found entry, now look for the right priority */
2267 }
2268 #ifdef NOTNOW
2270 /* Match label or priority */
2279 }
2280 #endif
2285 }
2286 }
2287 }
2290 /* Check alternative switches */
2299 }
2300 /* Substitute variables now */
2306 }
2308 }
2310 /* equivalent of extension_match_core() at the switch level */
2326 }
2331 /* XXX keep status = STATUS_NO_CONTEXT ? */
2333 }
2334 }
2336 /* Now try any includes we have in this context */
2339 if ((e = pbx_find_extension(chan, bypass, q, i->rname, exten, priority, label, callerid, action))) {
2340 #ifdef NEED_DEBUG_HERE
2342 #endif
2344 }
2347 }
2348 }
2350 }
2352 /*!
2353 * \brief extract offset:length from variable name.
2354 * \return 1 if there is a offset:length part, which is
2355 * trimmed off (values go into variables)
2356 */
2358 {
2367 parens++;
2369 parens--;
2374 }
2375 }
2377 }
2379 /*!
2380 *\brief takes a substring. It is ok to call with value == workspace.
2381 * \param value
2382 * \param offset < 0 means start from the end of the string and set the beginning
2383 * to be that many characters back.
2384 * \param length is the length of the substring, a value less than 0 means to leave
2385 * that many off the end.
2386 * \param workspace
2387 * \param workspace_len
2388 * Always return a copy in workspace.
2389 */
2390 static char *substring(const char *value, int offset, int length, char *workspace, size_t workspace_len)
2391 {
2399 /* Quick check if no need to do anything */
2405 if (offset < 0) /* If the negative offset was greater than the length of the string, just start at the beginning */
2407 }
2409 /* too large offset result in empty string so we know what to return */
2417 if (lr > offset - length) /* After we remove from the front and from the rear, is there anything left? */
2419 else
2421 }
2424 }
2426 /*! \brief Support for Asterisk built-in variables in the dialplan
2428 \note See also
2429 - \ref AstVar Channel variables
2430 - \ref AstCauses The HANGUPCAUSE variable
2431 */
2432 void pbx_retrieve_variable(struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp)
2433 {
2444 }
2445 /*
2446 * Make a copy of var because parse_variable_name() modifies the string.
2447 * Then if called directly, we might need to run substring() on the result;
2448 * remember this for later in 'need_substring', 'offset' and 'length'
2449 */
2453 /*
2454 * Look first into predefined variables, then into variable lists.
2455 * Variable 's' points to the result, according to the following rules:
2456 * s == ¬_found (set at the beginning) means that we did not find a
2457 * matching variable and need to look into more places.
2458 * If s != ¬_found, s is a valid result string as follows:
2459 * s = NULL if the variable does not have a value;
2460 * you typically do this when looking for an unset predefined variable.
2461 * s = workspace if the result has been assembled there;
2462 * typically done when the result is built e.g. with an snprintf(),
2463 * so we don't need to do an additional copy.
2464 * s != workspace in case we have a string, that needs to be copied
2465 * (the ast_copy_string is done once for all at the end).
2466 * Typically done when the result is already available in some string.
2467 */
2470 /* Names with common parts are looked up a piece at a time using strncmp. */
2485 }
2486 }
2488 s = ast_get_hint(workspace, workspacelen, NULL, 0, c, c->context, c->exten) ? workspace : NULL;
2490 s = ast_get_hint(NULL, 0, workspace, workspacelen, c, c->context, c->exten) ? workspace : NULL;
2505 }
2506 }
2516 }
2517 }
2518 /* if not found, look into chanvars or global vars */
2529 }
2530 }
2533 }
2542 }
2546 }
2549 {
2553 }
2558 };
2561 {
2574 }
2579 }
2591 }
2593 static int acf_exception_read(struct ast_channel *chan, const char *name, char *data, char *buf, size_t buflen)
2594 {
2608 else
2611 }
2625 };
2628 {
2642 }
2648 }
2650 ast_cli(a->fd, "%s Custom Functions:\n--------------------------------------------------------------------------------\n", like ? "Matching" : "Installed");
2655 count_acf++;
2657 }
2658 }
2664 }
2667 {
2669 /* Maximum number of characters added by terminal coloring is 22 */
2687 /* case-insensitive for convenience in this 'complete' function */
2693 }
2694 }
2698 }
2707 }
2711 else
2717 else
2723 else
2742 ast_cli(a->fd,"%s%s%s\n\n%s%s\n\n%s%s\n", infotitle, stxtitle, syntax, syntitle, synopsis, destitle, description);
2745 }
2748 {
2755 }
2759 }
2762 {
2774 }
2777 {
2793 }
2794 }
2796 /* Store in alphabetical order */
2801 }
2802 }
2803 AST_RWLIST_TRAVERSE_SAFE_END;
2809 ast_verb(2, "Registered custom function '%s'\n", term_color(tmps, acf->name, COLOR_BRCYAN, 0, sizeof(tmps)));
2812 }
2814 /*! \brief return a pointer to the arguments of the function,
2815 * and terminates the function name with '\\0'
2816 */
2818 {
2828 else
2830 }
2832 }
2835 {
2853 }
2855 }
2858 {
2876 }
2879 }
2881 static void pbx_substitute_variables_helper_full(struct ast_channel *c, struct varshead *headp, const char *cp1, char *cp2, int count)
2882 {
2883 /* Substitutes variables into cp2, based on string cp1, cp2 NO LONGER NEEDS TO BE ZEROED OUT!!!! */
2896 /* Assume we're copying the whole remaining string */
2913 }
2914 }
2917 /* Can't copy more than 'count' bytes */
2921 /* Copy that many bytes */
2928 }
2931 /* We have a variable. Find the start and end, and determine
2932 if we are going to have to recursively call ourselves on the
2933 contents */
2938 /* Find the end of it */
2941 needsub++;
2943 brackets++;
2945 brackets--;
2947 needsub++;
2948 vare++;
2949 }
2954 /* Skip totally over variable string */
2960 /* Store variable name (and truncate) */
2963 /* Substitute if necessary */
2972 }
2981 /* Evaluate function */
2991 /* Don't deallocate the varshead that was passed in */
2995 ast_log(LOG_ERROR, "Unable to allocate bogus channel for variable substitution. Function results may be blank.\n");
2996 }
2999 /* Retrieve variable value */
3001 }
3012 }
3014 /* We have an expression. Find the start and end, and determine
3015 if we are going to have to recursively call ourselves on the
3016 contents */
3021 /* Find the end of it */
3024 needsub++;
3025 brackets++;
3026 vare++;
3028 brackets++;
3030 brackets--;
3032 needsub++;
3033 vare++;
3034 }
3035 vare++;
3036 }
3041 /* Skip totally over expression */
3047 /* Store variable name (and truncate) */
3050 /* Substitute if necessary */
3059 }
3068 }
3069 }
3070 }
3071 }
3073 void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
3074 {
3076 }
3078 void pbx_substitute_variables_varshead(struct varshead *headp, const char *cp1, char *cp2, int count)
3079 {
3081 }
3083 static void pbx_substitute_variables(char *passdata, int datalen, struct ast_channel *c, struct ast_exten *e)
3084 {
3087 /* Nothing more to do */
3091 /* No variables or expressions in e->data, so why scan it? */
3095 }
3098 }
3100 /*!
3101 * \brief The return value depends on the action:
3102 *
3103 * E_MATCH, E_CANMATCH, E_MATCHMORE require a real match,
3104 * and return 0 on failure, -1 on match;
3105 * E_FINDLABEL maps the label to a priority, and returns
3106 * the priority on success, ... XXX
3107 * E_SPAWN, spawn an application,
3108 *
3109 * \retval 0 on success.
3110 * \retval -1 on failure.
3111 *
3112 * \note The channel is auto-serviced in this function, because doing an extension
3113 * match may block for a long time. For example, if the lookup has to use a network
3114 * dialplan switch, such as DUNDi or IAX2, it may take a while. However, the channel
3115 * auto-service code will queue up any important signalling frames to be processed
3116 * after this is done.
3117 */
3120 const char *label, const char *callerid, enum ext_match_t action, int *found, int combined_find_spawn)
3121 {
3151 ast_log(LOG_WARNING, "No application '%s' for extension (%s, %s, %d)\n", e->app, context, exten, priority);
3153 }
3160 #ifdef CHANNEL_TRACE
3162 #endif
3172 }
3183 }
3192 }
3193 return q.swo->exec(c, q.foundcontext ? q.foundcontext : context, exten, priority, callerid, q.data);
3194 }
3208 ast_log(LOG_NOTICE, "No such priority %d in extension '%s' in context '%s'\n", priority, exten, context);
3212 ast_log(LOG_NOTICE, "No such label '%s' in extension '%s' in context '%s'\n", label, exten, context);
3216 }
3219 }
3220 }
3222 /*! \brief Find hint for given extension in context */
3223 static struct ast_exten *ast_hint_extension(struct ast_channel *c, const char *context, const char *exten)
3224 {
3233 }
3235 /*! \brief Check state of extension by using hints */
3237 {
3274 }
3277 }
3279 /*! \brief Return extension_state as string */
3281 {
3287 }
3289 }
3291 /*! \brief Check extension state for an extension by using hint */
3293 {
3301 }
3304 {
3320 }
3324 /* Get device state for this hint */
3330 /* Device state changed since last check - notify the watchers */
3332 /* For general callbacks */
3335 }
3337 /* For extension callbacks */
3340 }
3343 }
3347 }
3349 /*! \brief Add watcher for extension states */
3352 {
3357 /* If there's no context and extension: add callback to statecbs list */
3366 }
3367 }
3369 /* Now insert the callback */
3373 }
3383 }
3388 /* This callback type is for only one hint, so get the hint */
3392 }
3394 /* If this is a pattern, dynamically create a new extension for this
3395 * particular match. Note that this will only happen once for each
3396 * individual extension, because the pattern will no longer match first.
3397 */
3405 }
3406 }
3408 /* Find the hint in the list of hints */
3414 }
3417 /* We have no hint, sorry */
3420 }
3422 /* Now insert the callback in the callback list */
3426 }
3437 }
3439 /*! \brief Remove a watcher from the callback list */
3441 {
3455 }
3456 }
3457 AST_LIST_TRAVERSE_SAFE_END
3465 }
3466 }
3467 AST_LIST_TRAVERSE_SAFE_END
3471 }
3472 }
3476 }
3481 }
3483 /*! \brief Add hint to hint list, check initial extension state */
3485 {
3493 /* Search if hint exists, do nothing */
3497 ast_debug(2, "HINTS: Not re-adding existing hint %s: %s\n", ast_get_extension_name(e), ast_get_extension_app(e));
3499 }
3500 }
3502 ast_debug(2, "HINTS: Adding hint %s: %s\n", ast_get_extension_name(e), ast_get_extension_app(e));
3507 }
3508 /* Initialize and insert new item at the top */
3515 }
3517 /*! \brief Change hint for an extension */
3519 {
3529 }
3530 }
3534 }
3536 /*! \brief Remove hint from extension */
3538 {
3539 /* Cleanup the Notifys if hint is removed */
3552 /* Notify with -1 and remove all callbacks */
3556 }
3564 }
3565 AST_RWLIST_TRAVERSE_SAFE_END;
3568 }
3571 /*! \brief Get hint for channel */
3572 int ast_get_hint(char *hint, int hintsize, char *name, int namesize, struct ast_channel *c, const char *context, const char *exten)
3573 {
3583 }
3585 }
3587 }
3589 int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
3590 {
3592 }
3594 int ast_findlabel_extension(struct ast_channel *c, const char *context, const char *exten, const char *label, const char *callerid)
3595 {
3597 }
3599 int ast_findlabel_extension2(struct ast_channel *c, struct ast_context *con, const char *exten, const char *label, const char *callerid)
3600 {
3602 }
3604 int ast_canmatch_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
3605 {
3606 return pbx_extension_helper(c, NULL, context, exten, priority, NULL, callerid, E_CANMATCH, 0, 0);
3607 }
3609 int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
3610 {
3611 return pbx_extension_helper(c, NULL, context, exten, priority, NULL, callerid, E_MATCHMORE, 0, 0);
3612 }
3614 int ast_spawn_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid, int *found, int combined_find_spawn)
3615 {
3616 return pbx_extension_helper(c, NULL, context, exten, priority, NULL, callerid, E_SPAWN, found, combined_find_spawn);
3617 }
3619 /*! helper function to set extension and priority */
3621 {
3626 }
3628 /*!
3629 * \brief collect digits from the channel into the buffer.
3630 * \retval 0 on timeout or done.
3631 * \retval -1 on error.
3632 */
3634 {
3639 /* As long as we're willing to wait, and as long as it's not defined,
3640 keep reading digits until we can't possibly get a right answer anymore. */
3652 }
3654 }
3655 }
3657 }
3660 {
3666 /* A little initial setup here */
3669 /* XXX and now what ? */
3671 }
3674 /* Set reasonable defaults */
3681 /* Start by trying whatever the channel is set to */
3683 /* If not successful fall back to 's' */
3684 ast_verb(2, "Starting %s at %s,%s,%d failed so falling back to exten 's'\n", c->name, c->context, c->exten, c->priority);
3685 /* XXX the original code used the existing priority in the call to
3686 * ast_exists_extension(), and reset it to 1 afterwards.
3687 * I believe the correct thing is to set it to 1 immediately.
3688 */
3691 /* JK02: And finally back to default if everything else failed */
3692 ast_verb(2, "Starting %s at %s,%s,%d still failed so falling back to context 'default'\n", c->name, c->context, c->exten, c->priority);
3694 }
3695 }
3703 /* loop on priorities in this context/exten */
3704 while ( !(res = ast_spawn_extension(c, c->context, c->exten, c->priority, c->cid.cid_num, &found,1))) {
3705 if (c->_softhangup == AST_SOFTHANGUP_TIMEOUT && ast_exists_extension(c, c->context, "T", 1, c->cid.cid_num)) {
3707 /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
3710 } else if (c->_softhangup == AST_SOFTHANGUP_TIMEOUT && ast_exists_extension(c, c->context, "e", 1, c->cid.cid_num)) {
3712 /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
3723 }
3727 /* Something bad happened, or a hangup has been requested. */
3734 ast_debug(1, "Spawn extension (%s,%s,%d) exited KEEPALIVE on '%s'\n", c->context, c->exten, c->priority, c->name);
3735 ast_verb(2, "Spawn extension (%s, %s, %d) exited KEEPALIVE on '%s'\n", c->context, c->exten, c->priority, c->name);
3738 ast_debug(1, "Spawn extension (%s,%s,%d) exited INCOMPLETE on '%s'\n", c->context, c->exten, c->priority, c->name);
3739 ast_verb(2, "Spawn extension (%s, %s, %d) exited INCOMPLETE on '%s'\n", c->context, c->exten, c->priority, c->name);
3741 /* Don't cycle on incomplete - this will happen if the only extension that matches is our "incomplete" extension */
3748 }
3750 ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", c->context, c->exten, c->priority, c->name);
3751 ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", c->context, c->exten, c->priority, c->name);
3754 /* if we are already on the 'e' exten, don't jump to it again */
3756 ast_verb(2, "Spawn extension (%s, %s, %d) exited ERROR while already on 'e' exten on '%s'\n", c->context, c->exten, c->priority, c->name);
3761 }
3762 }
3767 } else if (c->_softhangup == AST_SOFTHANGUP_TIMEOUT && ast_exists_extension(c, c->context, "T", 1, c->cid.cid_num)) {
3769 /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
3778 }
3779 }
3780 }
3784 /*!\note
3785 * We get here on a failure of some kind: non-existing extension or
3786 * hangup. We have options, here. We can either catch the failure
3787 * and continue, or we can drop out entirely. */
3790 /*!\note
3791 * If there is no match at priority 1, it is not a valid extension anymore.
3792 * Try to continue at "i" (for invalid) or "e" (for exception) or exit if
3793 * neither exist.
3794 */
3796 ast_verb(3, "Sent into invalid extension '%s' in context '%s' on %s\n", c->exten, c->context, c->name);
3802 ast_log(LOG_WARNING, "Channel '%s' sent into invalid extension '%s' in context '%s', but no invalid handler\n",
3806 }
3808 /* If we get this far with AST_SOFTHANGUP_TIMEOUT, then we know that the "T" extension is next. */
3829 }
3835 if (!timeout && ast_exists_extension(c, c->context, dst_exten, 1, c->cid.cid_num)) /* Prepare the next cycle */
3838 /* No such extension */
3840 /* An invalid extension */
3848 ast_log(LOG_WARNING, "Invalid extension '%s', but no rule 'i' in context '%s'\n", dst_exten, c->context);
3851 }
3853 /* A simple timeout */
3863 }
3864 }
3865 }
3869 }
3870 }
3871 }
3876 if ((res != AST_PBX_KEEPALIVE) && ast_exists_extension(c, c->context, "h", 1, c->cid.cid_num)) {
3878 while ((res = ast_spawn_extension(c, c->context, c->exten, c->priority, c->cid.cid_num, &found, 1)) == 0) {
3880 }
3882 /* Something bad happened, or a hangup has been requested. */
3883 ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", c->context, c->exten, c->priority, c->name);
3884 ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", c->context, c->exten, c->priority, c->name);
3885 }
3886 }
3894 }
3896 /*!
3897 * \brief Increase call count for channel
3898 * \retval 0 on success
3899 * \retval non-zero if a configured limit (maxcalls, maxload, minmemfree) was reached
3900 */
3902 {
3905 #if defined(HAVE_SYSINFO)
3908 #endif
3913 ast_log(LOG_WARNING, "Maximum call limit of %d calls exceeded by '%s'!\n", option_maxcalls, c->name);
3915 }
3916 }
3920 ast_log(LOG_WARNING, "Maximum loadavg limit of %f load exceeded by '%s' (currently %f)!\n", option_maxload, c->name, curloadavg);
3922 }
3923 }
3924 #if defined(HAVE_SYSINFO)
3927 /* make sure that the free system memory is above the configured low watermark
3928 * convert the amount of freeram from mem_units to MB */
3932 ast_log(LOG_WARNING, "Available system memory (~%ldMB) is below the configured low watermark (%ldMB)\n", curfreemem, option_minmemfree);
3934 }
3935 }
3936 }
3937 #endif
3940 countcalls++;
3941 totalcalls++;
3942 }
3946 }
3949 {
3952 countcalls--;
3954 }
3957 {
3968 }
3971 {
3972 /* Oh joyeous kernel, we're a new thread, with nothing to do but
3973 answer this channel and get it going.
3974 */
3975 /* NOTE:
3976 The launcher of this function _MUST_ increment 'countcalls'
3977 before invoking the function; it will be decremented when the
3978 PBX has finished running on the channel
3979 */
3988 }
3991 {
3992 pthread_t t;
3997 }
4002 /* Start a new thread, and get something handling this channel. */
4006 }
4009 }
4012 {
4022 }
4025 {
4027 }
4030 {
4032 }
4035 {
4039 }
4042 {
4046 }
4049 {
4052 }
4057 }
4058 }
4060 /*!
4061 * \brief lookup for a context with a given name,
4062 * \retval with conlock held if found.
4063 * \retval NULL if not found.
4064 */
4066 {
4075 #ifdef NOTNOW
4080 }
4081 #endif
4086 }
4088 /*!
4089 * \brief Remove included contexts.
4090 * This function locks contexts list by &conlist, search for the right context
4091 * structure, leave context list locked and call ast_context_remove_include2
4092 * which removes include, unlock contexts list and return ...
4093 */
4094 int ast_context_remove_include(const char *context, const char *include, const char *registrar)
4095 {
4100 /* found, remove include from this context ... */
4103 }
4105 }
4107 /*!
4108 * \brief Locks context, remove included contexts, unlocks context.
4109 * When we call this function, &conlock lock must be locked, because when
4110 * we giving *con argument, some process can remove/change this context
4111 * and after that there can be segfault.
4112 *
4113 * \retval 0 on success.
4114 * \retval -1 on failure.
4115 */
4116 int ast_context_remove_include2(struct ast_context *con, const char *include, const char *registrar)
4117 {
4123 /* find our include */
4127 /* remove from list */
4128 ast_verb(3, "Removing inclusion of context '%s' in context '%s; registrar=%s'\n", include, ast_get_context_name(con), registrar);
4131 else
4133 /* free include and return */
4137 }
4138 }
4143 }
4145 /*!
4146 * \note This function locks contexts list by &conlist, search for the rigt context
4147 * structure, leave context list locked and call ast_context_remove_switch2
4148 * which removes switch, unlock contexts list and return ...
4149 */
4150 int ast_context_remove_switch(const char *context, const char *sw, const char *data, const char *registrar)
4151 {
4156 /* remove switch from this context ... */
4159 }
4161 }
4163 /*!
4164 * \brief This function locks given context, removes switch, unlock context and
4165 * return.
4166 * \note When we call this function, &conlock lock must be locked, because when
4167 * we giving *con argument, some process can remove/change this context
4168 * and after that there can be segfault.
4169 *
4170 */
4171 int ast_context_remove_switch2(struct ast_context *con, const char *sw, const char *data, const char *registrar)
4172 {
4178 /* walk switches */
4182 /* found, remove from list */
4183 ast_verb(3, "Removing switch '%s' from context '%s; registrar=%s'\n", sw, ast_get_context_name(con), registrar);
4188 }
4189 }
4190 AST_LIST_TRAVERSE_SAFE_END;
4195 }
4197 /*
4198 * \note This functions lock contexts list, search for the right context,
4199 * call ast_context_remove_extension2, unlock contexts list and return.
4200 * In this function we are using
4201 */
4202 int ast_context_remove_extension(const char *context, const char *extension, int priority, const char *registrar)
4203 {
4204 return ast_context_remove_extension_callerid(context, extension, priority, NULL, 0, registrar);
4205 }
4207 int ast_context_remove_extension_callerid(const char *context, const char *extension, int priority, const char *callerid, int matchcallerid, const char *registrar)
4208 {
4213 ret = ast_context_remove_extension_callerid2(c, extension, priority, callerid, matchcallerid, registrar, 1);
4215 }
4217 }
4219 /*!
4220 * \brief This functionc locks given context, search for the right extension and
4221 * fires out all peer in this extensions with given priority. If priority
4222 * is set to 0, all peers are removed. After that, unlock context and
4223 * return.
4224 * \note When do you want to call this function, make sure that &conlock is locked,
4225 * because some process can handle with your *con context before you lock
4226 * it.
4227 *
4228 */
4229 int ast_context_remove_extension2(struct ast_context *con, const char *extension, int priority, const char *registrar, int already_locked)
4230 {
4231 return ast_context_remove_extension_callerid2(con, extension, priority, NULL, 0, registrar, already_locked);
4232 }
4234 int ast_context_remove_extension_callerid2(struct ast_context *con, const char *extension, int priority, const char *callerid, int matchcallerid, const char *registrar, int already_locked)
4235 {
4247 /* Handle this is in the new world */
4249 /* FIXME For backwards compatibility, if callerid==NULL, then remove ALL
4250 * peers, not just those matching the callerid. */
4251 #ifdef NEED_DEBUG
4252 ast_verb(3,"Removing %s/%s/%d%s%s from trees, registrar=%s\n", con->name, extension, priority, matchcallerid ? "/" : "", matchcallerid ? callerid : "", registrar);
4253 #endif
4254 #ifdef CONTEXT_DEBUG
4256 #endif
4257 /* find this particular extension */
4259 ex.matchcid = matchcallerid && !ast_strlen_zero(callerid); /* don't say match if there's no callerid */
4267 ast_log(LOG_ERROR,"Trying to delete the exten %s from context %s, but could not remove from the root_table\n", extension, con->name);
4273 x->deleted = 1; /* with this marked as deleted, it will never show up in the scoreboard, and therefore never be found */
4276 ast_log(LOG_WARNING,"Trying to delete an exten from a context, but the pattern tree node returned isn't a full extension\n");
4277 }
4278 }
4287 ast_log(LOG_ERROR,"Did not remove this priority label (%d/%s) from the peer_label_table of context %s, extension %s!\n", priority, exten2->label, con->name, exten2->exten);
4288 }
4292 ast_log(LOG_ERROR,"Did not remove this priority (%d) from the peer_table of context %s, extension %s!\n", priority, con->name, exten2->exten);
4296 }
4298 /* well, if the last priority of an exten is to be removed,
4299 then, the extension is removed, too! */
4302 ast_log(LOG_ERROR,"Did not remove this exten (%s) from the context root_table (%s) (priority %d)\n", exten->exten, con->name, priority);
4306 x->deleted = 1; /* with this marked as deleted, it will never show up in the scoreboard, and therefore never be found */
4308 }
4309 }
4310 }
4314 }
4315 }
4317 /* hmmm? this exten is not in this pattern tree? */
4320 }
4321 #ifdef NEED_DEBUG
4325 }
4326 #endif
4328 /* scan the extension list to find first matching extension-registrar */
4332 (!matchcallerid || (!ast_strlen_zero(callerid) && !ast_strlen_zero(exten->cidmatch) && !strcmp(exten->cidmatch, callerid)) || (ast_strlen_zero(callerid) && ast_strlen_zero(exten->cidmatch))))
4334 }
4336 /* we can't find right extension */
4340 }
4342 /* scan the priority list to remove extension with exten->priority == priority */
4344 peer && !strcmp(peer->exten, extension) && (!matchcallerid || (!ast_strlen_zero(callerid) && !ast_strlen_zero(peer->cidmatch) && !strcmp(peer->cidmatch,callerid)) || (ast_strlen_zero(callerid) && ast_strlen_zero(peer->cidmatch)));
4345 peer = next_peer, next_peer = next_peer ? (next_peer->peer ? next_peer->peer : next_peer->next) : NULL) {
4351 /* we are first priority extension? */
4353 /*
4354 * We are first in the priority chain, so must update the extension chain.
4355 * The next node is either the next priority or the next extension
4356 */
4359 /* move the peer_table and peer_label_table down to the next peer, if
4360 it is there */
4365 }
4370 }
4373 }
4376 }
4378 /* now, free whole priority extension */
4382 }
4383 }
4387 }
4390 /*!
4391 * \note This function locks contexts list by &conlist, searches for the right context
4392 * structure, and locks the macrolock mutex in that context.
4393 * macrolock is used to limit a macro to be executed by one call at a time.
4394 */
4396 {
4409 #ifdef NOTNOW
4415 }
4416 }
4418 #endif
4421 /* if we found context, lock macrolock */
4426 }
4428 /*!
4429 * \note This function locks contexts list by &conlist, searches for the right context
4430 * structure, and unlocks the macrolock mutex in that context.
4431 * macrolock is used to limit a macro to be executed by one call at a time.
4432 */
4434 {
4445 #ifdef NOTNOW
4451 }
4452 }
4454 #endif
4457 /* if we found context, unlock macrolock */
4462 }
4464 /*! \brief Dynamically register a new dial plan application */
4465 int ast_register_application2(const char *app, int (*execute)(struct ast_channel *, void *), const char *synopsis, const char *description, void *mod)
4466 {
4479 }
4486 }
4494 /* Store in alphabetical order */
4499 }
4500 }
4501 AST_RWLIST_TRAVERSE_SAFE_END;
4505 ast_verb(2, "Registered application '%s'\n", term_color(tmps, tmp->name, COLOR_BRCYAN, 0, sizeof(tmps)));
4510 }
4512 /*
4513 * Append to the list. We don't have a tail pointer because we need
4514 * to scan the list anyways to check for duplicates during insertion.
4515 */
4517 {
4526 }
4527 }
4532 }
4535 {
4539 }
4541 /*
4542 * Help for CLI commands ...
4543 */
4545 /*
4546 * \brief 'show application' CLI command implementation function...
4547 */
4549 {
4564 /*
4565 * There is a possibility to show informations about more than one
4566 * application at one time. You can type 'show application Dial Echo' and
4567 * you will see informations about these two applications ...
4568 */
4570 /* return the n-th [partial] matching entry */
4576 }
4577 }
4581 }
4586 /* ... go through all applications ... */
4589 /* ... compare this application name with all arguments given
4590 * to 'show application' command ... */
4593 /* Maximum number of characters added by terminal coloring is 22 */
4602 else
4608 else
4626 /* ... one of our applications, show info ...*/
4633 }
4634 }
4635 }
4636 }
4639 /* we found at least one app? no? */
4643 }
4646 }
4648 /*! \brief handle_show_hints: CLI support for listing registered dial plan hints */
4650 {
4665 }
4672 }
4673 /* ... we have hints ... */
4678 watchers++;
4679 }
4685 num++;
4686 }
4691 }
4693 /*! \brief autocomplete for CLI command 'core show hint' */
4695 {
4707 /* walk through all hints */
4712 }
4713 }
4717 }
4719 /*! \brief handle_show_hint: CLI support for listing registered dial plan hint */
4721 {
4736 }
4746 }
4752 watchers++;
4753 }
4759 num++;
4760 }
4761 }
4765 else
4768 }
4771 /*! \brief handle_show_switches: CLI support for listing registered dial plan switches */
4773 {
4785 }
4793 }
4802 }
4804 static char *handle_show_applications(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
4805 {
4823 }
4831 }
4833 /* core list applications like <keyword> */
4838 }
4840 /* core list applications describing <keyword1> [<keyword2>] [...] */
4845 }
4849 total_apps++;
4853 total_match++;
4854 }
4857 /* Match all words on command line */
4864 total_match++;
4865 }
4866 }
4867 }
4870 }
4873 ast_cli(a->fd," %20s: %s\n", aa->name, aa->synopsis ? aa->synopsis : "<Synopsis not available>");
4874 }
4875 }
4880 }
4885 }
4887 /*
4888 * 'show dialplan' CLI command implementation functions ...
4889 */
4892 {
4898 /* we are do completion of [exten@]context on second position only */
4906 /* walk through all contexts and return the n-th match */
4911 }
4912 }
4917 }
4919 /*! \brief Counters for the show dialplan manager command */
4927 };
4929 /*! \brief helper function to print an extension */
4931 {
4939 (!ast_strlen_zero(ast_get_extension_app_data(e)) ? (char *)ast_get_extension_app_data(e) : ""));
4940 }
4941 }
4943 /* XXX not verified */
4944 static int show_dialplan_helper(int fd, const char *context, const char *exten, struct dialplan_counters *dpc, struct ast_include *rinclude, int includecount, const char *includes[])
4945 {
4951 /* walk all contexts ... */
4966 /* are we looking for exten too? if yes, we print context
4967 * only if we find our extension.
4968 * Otherwise print context even if empty ?
4969 * XXX i am not sure how the rinclude is handled.
4970 * I think it ought to go inside.
4971 */
4977 }
4979 /* walk extensions ... */
4989 /* may we print context info? */
4998 }
5000 }
5003 /* write extension name and first peer */
5005 snprintf(buf, sizeof(buf), "'%s' (CID match '%s') => ", ast_get_extension_name(e), e->cidmatch);
5006 else
5015 /* walk next extension peers */
5022 else
5028 }
5029 }
5031 /* walk included and write info ... */
5036 /* Check all includes for the requested extension */
5044 dupe++;
5046 }
5047 }
5052 ast_log(LOG_WARNING, "Avoiding circular include of %s within %s\n", ast_get_include_name(i), context);
5053 }
5054 }
5058 }
5059 }
5061 /* walk ignore patterns and write info ... */
5071 }
5072 }
5081 }
5082 }
5085 {
5088 ast_cli(fd,"\r\n Explanation: Node Contents Format = <char(s) to match>:<pattern?>:<specif>:[matched extension]\r\n");
5089 ast_cli(fd, " Where <char(s) to match> is a set of chars, any one of which should match the current character\r\n");
5091 ast_cli(fd, " <specif>: an assigned 'exactness' number for this matching char. The lower the number, the more exact the match\r\n");
5092 ast_cli(fd, " [matched exten]: If all chars matched to this point, which extension this matches. In form: EXTEN:<exten string> \r\n");
5093 ast_cli(fd, " In general, you match a trie node to a string character, from left to right. All possible matching chars\r\n");
5094 ast_cli(fd, " are in a string vertically, separated by an unbroken string of '+' characters.\r\n\r\n");
5096 }
5100 /* if we print something in context, make an empty line */
5103 }
5107 }
5110 {
5112 /* Variables used for different counters */
5125 }
5132 /* we obtain [exten@]context? if yes, split them ... */
5137 /* change empty strings to NULL */
5142 }
5145 }
5146 /* else Show complete dial plan, context and exten are NULL */
5149 /* check for input failure and throw some error messages */
5153 }
5159 else
5162 exten);
5164 }
5171 /* everything ok */
5173 }
5175 /*! \brief Send ack once */
5177 {
5179 }
5181 /*! \brief Show dialplan extensions
5182 * XXX this function is similar but not exactly the same as the CLI's
5183 * show dialplan. Must check whether the difference is intentional or not.
5184 */
5189 {
5200 /* try to lock contexts */
5205 }
5223 }
5225 /* XXX note- an empty context is not printed */
5230 /* looking for extension? is this our extension? */
5232 /* not the one we are looking for, continue */
5235 }
5240 /* may we print context info? */
5252 astman_append(s, "Context: %s\r\nExtension: %s\r\n", ast_get_context_name(c), ast_get_extension_name(e) );
5254 /* XXX maybe make this conditional, if p != e ? */
5261 astman_append(s, "Priority: %d\r\nApplication: %s\r\nAppData: %s\r\n", prio, ast_get_extension_app(p), (char *) ast_get_extension_app_data(p));
5262 }
5264 }
5265 }
5270 /* Check all includes for the requested extension */
5276 astman_append(s, "Context: %s\r\nIncludeContext: %s\r\nRegistrar: %s\r\n", ast_get_context_name(c), ast_get_include_name(i), ast_get_include_registrar(i));
5279 }
5280 }
5292 astman_append(s, "Context: %s\r\nIgnorePattern: %s\r\nRegistrar: %s\r\n", ast_get_context_name(c), ipname, ast_get_ignorepat_registrar(ip));
5294 }
5295 }
5302 astman_append(s, "Context: %s\r\nSwitch: %s/%s\r\nRegistrar: %s\r\n", ast_get_context_name(c), ast_get_switch_name(sw), ast_get_switch_data(sw), ast_get_switch_registrar(sw));
5305 }
5306 }
5309 }
5314 /* Nothing new under the sun */
5318 }
5319 }
5321 /*! \brief Manager listing of dial plan */
5323 {
5329 /* Variables used for different counters */
5334 else
5350 }
5356 else
5360 }
5368 "%s"
5369 "\r\n", counters.total_items, counters.total_exten, counters.total_prio, counters.total_context, idtext);
5371 /* everything ok */
5373 }
5384 /*! \brief CLI support for listing global variables in a parseable way */
5386 {
5399 }
5403 i++;
5405 }
5410 }
5412 static char *handle_show_globals_deprecated(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
5413 {
5419 }
5421 /*! \brief CLI support for listing chanvar's variables in a parseable way */
5423 {
5425 struct ast_str *vars = ast_str_alloca(BUFSIZ * 4); /* XXX large because we might have lots of channel vars */
5436 }
5444 }
5449 }
5452 }
5455 {
5465 }
5474 }
5476 static char *handle_set_global_deprecated(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
5477 {
5482 }
5485 {
5498 }
5510 }
5514 ast_cli(a->fd, "\n -- Channel variable '%s' set to '%s' for '%s'\n", var_name, var_value, chan_name);
5517 }
5519 static char *handle_set_chanvar_deprecated(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
5520 {
5525 }
5527 static char *handle_set_extenpatternmatchnew(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
5528 {
5540 }
5548 ast_cli(a->fd, "\n -- Still using the NEW pattern match algorithm for extension names in the dialplan.\n");
5549 else
5550 ast_cli(a->fd, "\n -- Switched to using the NEW pattern match algorithm for extension names in the dialplan.\n");
5553 }
5555 static char *handle_unset_extenpatternmatchnew(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
5556 {
5568 }
5576 ast_cli(a->fd, "\n -- Still using the OLD pattern match algorithm for extension names in the dialplan.\n");
5577 else
5578 ast_cli(a->fd, "\n -- Switched to using the OLD pattern match algorithm for extension names in the dialplan.\n");
5581 }
5583 /*
5584 * Deprecated CLI commands
5585 */
5587 static struct ast_cli_entry cli_show_globals_deprecated = AST_CLI_DEFINE(handle_show_globals_deprecated, "Show global dialplan variables.");
5588 static struct ast_cli_entry cli_set_chanvar_deprecated = AST_CLI_DEFINE(handle_set_chanvar_deprecated, "Set a channel variable.");
5589 static struct ast_cli_entry cli_set_global_deprecated = AST_CLI_DEFINE(handle_set_global_deprecated, "Set global dialplan variable.");
5591 /*
5592 * CLI entries for upper commands ...
5593 */
5600 AST_CLI_DEFINE(handle_show_globals, "Show global dialplan variables", .deprecate_cmd = &cli_show_globals_deprecated),
5604 AST_CLI_DEFINE(handle_set_global, "Set global dialplan variable", .deprecate_cmd = &cli_set_global_deprecated),
5605 AST_CLI_DEFINE(handle_set_chanvar, "Set a channel variable", .deprecate_cmd = &cli_set_chanvar_deprecated),
5607 AST_CLI_DEFINE(handle_unset_extenpatternmatchnew, "Use the Old extension pattern matching algorithm."),
5608 AST_CLI_DEFINE(handle_set_extenpatternmatchnew, "Use the New extension pattern matching algorithm."),
5609 };
5612 {
5622 }
5623 }
5624 }
5628 }
5631 {
5642 }
5643 }
5644 AST_RWLIST_TRAVERSE_SAFE_END;
5648 }
5650 struct ast_context *ast_context_find_or_create(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *name, const char *registrar)
5651 {
5658 ast_hashtab_compare_contexts,
5659 ast_hashtab_resize_java,
5660 ast_hashtab_newsize_java,
5661 ast_hashtab_hash_contexts,
5663 }
5674 }
5675 } else { /* local contexts just in a linked list; search there for the new context; slow, linear search, but not frequent */
5681 }
5682 }
5697 }
5705 ast_debug(1, "Registered context '%s'(%p) in table %p registrar: %s\n", tmp->name, tmp, contexts_table, registrar);
5706 ast_verb(3, "Registered extension context '%s' (%p) in table %p; registrar: %s\n", tmp->name, tmp, contexts_table, registrar);
5713 ast_debug(1, "Registered context '%s'(%p) in local table %p; registrar: %s\n", tmp->name, tmp, exttable, registrar);
5714 ast_verb(3, "Registered extension context '%s' (%p) in local table %p; registrar: %s\n", tmp->name, tmp, exttable, registrar);
5715 }
5717 }
5719 void __ast_context_destroy(struct ast_context *list, struct ast_hashtab *contexttab, struct ast_context *con, const char *registrar);
5728 };
5732 static void context_merge_incls_swits_igps_other_registrars(struct ast_context *new, struct ast_context *old, const char *registrar)
5733 {
5738 ast_verb(3, "merging incls/swits/igpats from old(%s) to new(%s) context, registrar = %s\n", ast_get_context_name(old), ast_get_context_name(new), registrar);
5739 /* copy in the includes, switches, and ignorepats */
5740 /* walk through includes */
5745 }
5747 /* walk through switches */
5751 ast_context_add_switch2(new, ast_get_switch_name(sw), ast_get_switch_data(sw), ast_get_switch_eval(sw), ast_get_switch_registrar(sw));
5752 }
5754 /* walk thru ignorepats ... */
5759 }
5760 }
5763 /* the purpose of this routine is to duplicate a context, with all its substructure,
5764 except for any extens that have a matching registrar */
5765 static void context_merge(struct ast_context **extcontexts, struct ast_hashtab *exttable, struct ast_context *context, const char *registrar)
5766 {
5767 struct ast_context *new = ast_hashtab_lookup(exttable, context); /* is there a match in the new set? */
5774 /* We'll traverse all the extensions/prios, and see which are not registrar'd with
5775 the current registrar, and copy them to the new context. If the new context does not
5776 exist, we'll create it "on demand". If no items are in this context to copy, then we'll
5777 only create the empty matching context if the old one meets the criteria */
5786 }
5796 }
5799 }
5800 /* make sure the new context exists, so we have somewhere to stick this exten/prio */
5802 new = ast_context_find_or_create(extcontexts, exttable, context->name, prio_item->registrar); /* a new context created via priority from a different context in the old dialplan, gets its registrar from the prio's registrar */
5803 }
5805 /* copy in the includes, switches, and ignorepats */
5809 }
5812 ast_log(LOG_ERROR,"Could not allocate a new context for %s in merge_and_delete! Danger!\n", context->name);
5814 }
5815 /* we will not replace existing entries in the new context with stuff from the old context.
5816 but, if this is because of some sort of registrar conflict, we ought to say something... */
5823 ast_verb(3,"Dropping old dialplan item %s/%s/%d [%s(%s)] (registrar=%s) due to conflict with new dialplan\n",
5824 context->name, prio_item->exten, prio_item->priority, prio_item->app, (char*)prio_item->data, prio_item->registrar);
5826 /* we do NOT pass the priority data from the old to the new -- we pass a copy of it, so no changes to the current dialplan take place,
5827 and no double frees take place, either! */
5828 insert_count++;
5829 }
5830 }
5832 }
5834 }
5838 /* we could have given it the registrar of the other module who incremented the refcount,
5839 but that's not available, so we give it the registrar we know about */
5842 /* copy in the includes, switches, and ignorepats */
5844 }
5845 }
5848 /* XXX this does not check that multiple contexts are merged */
5849 void ast_merge_contexts_and_delete(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *registrar)
5850 {
5862 /* it is very important that this function hold the hint list lock _and_ the conlock
5863 during its operation; not only do we need to ensure that the list of contexts
5864 and extensions does not change, but also that no hint callbacks (watchers) are
5865 added or removed during the merge/delete process
5867 in addition, the locks _must_ be taken in this order, because there are already
5868 other code paths that use this order
5869 */
5879 }
5884 what you must do If this isn't done, the following
5885 wrlock is a guraranteed deadlock */
5889 }
5894 /* preserve all watchers for hints associated with this registrar */
5907 }
5908 }
5910 /* save the old table and list */
5914 /* move in the new table and list */
5918 /* restore the watchers for hints that can be found; notify those that
5919 cannot be restored
5920 */
5923 exten = pbx_find_extension(NULL, NULL, &q, this->context, this->exten, PRIORITY_HINT, NULL, "", E_MATCH);
5924 /* If this is a pattern, dynamically create a new extension for this
5925 * particular match. Note that this will only happen once for each
5926 * individual extension, because the pattern will no longer match first.
5927 */
5932 }
5934 /* Find the hint in the list of hints */
5938 }
5940 /* this hint has been removed, notify the watchers */
5944 }
5948 }
5950 }
5956 /* the old list and hashtab no longer are relevant, delete them while the rest of asterisk
5957 is now freely using the new stuff instead */
5966 }
5971 ast_verb(3,"Time to scan old dialplan and merge leftovers back into the new: %8.6f sec\n", ft);
5985 }
5987 /*
5988 * errno values
5989 * EBUSY - can't lock
5990 * ENOENT - no existence of context
5991 */
5993 {
6000 }
6002 }
6004 /*! \brief Helper for get_range.
6005 * return the index of the matching entry, starting from 1.
6006 * If names is not supplied, try numeric values.
6007 */
6009 {
6016 }
6019 }
6021 }
6023 /*! \brief helper function to return a range up to max (7, 12, 31 respectively).
6024 * names, if supplied, is an array of names that should be mapped to numbers.
6025 */
6027 {
6031 /* Check for whole range */
6036 /* Get start and ending position */
6040 /* Find the start */
6045 }
6046 s--;
6052 }
6053 e--;
6056 }
6057 /* Fill the mask. Remember that ranges are cyclic */
6065 s++;
6066 }
6067 }
6069 }
6071 /*! \brief store a bitmask of valid times, one bit each 2 minute */
6073 {
6078 /* int cth, ctm; */
6080 /* start disabling all times, fill the fields with 0's, as they may contain garbage */
6083 /* 2-minutes per bit, since the mask has only 32 bits :( */
6084 /* Star is all times */
6089 }
6090 /* Otherwise expect a range */
6095 }
6097 /* XXX why skip non digits ? */
6099 e++;
6103 }
6107 }
6111 }
6112 /* XXX this needs to be optimized */
6113 #if 1
6118 }
6123 }
6124 /* Go through the time and enable each appropriate bit */
6127 }
6128 /* Do the last one */
6130 #else
6132 /* Initialize masks to blank */
6136 /* First hour with more than one hour */
6139 /* Only one hour */
6142 /* In between first and last hours (more than 2 hours) */
6145 /* Last hour with more than one hour */
6148 )
6150 }
6151 }
6152 #endif
6153 /* All done */
6155 }
6158 {
6166 NULL,
6167 };
6170 {
6183 NULL,
6184 };
6187 {
6191 /* Check for empty just in case */
6194 /* make a copy just in case we were passed a static string */
6197 /* Assume everything except time */
6201 /* on each call, use strsep() to move info to the next argument */
6210 }
6213 {
6219 /* If it's not the right month, return */
6223 /* If it's not that time of the month.... */
6224 /* Warning, tm_mday has range 1..31! */
6228 /* If it's not the right day of the week */
6232 /* Sanity check the hour just to be safe */
6236 }
6238 /* Now the tough part, we calculate if it fits
6239 in the right time based on min/hour */
6243 /* If we got this far, then we're good */
6245 }
6247 /*
6248 * errno values
6249 * ENOMEM - out of memory
6250 * EBUSY - can't lock
6251 * EEXIST - already included
6252 * EINVAL - there is no existence of context for inclusion
6253 */
6256 {
6266 /* allocate new include structure ... */
6269 /* Fill in this structure. Use 'p' for assignments, as the fields
6270 * in the structure are 'const char *'
6271 */
6278 /* Strip off timing info, and process if it is there */
6282 }
6288 /* ... go to last include and check if context is already included too... */
6295 }
6297 }
6299 /* ... include new context into context list, unlock, return */
6302 else
6304 ast_verb(3, "Including context '%s' in context '%s'\n", new_include->name, ast_get_context_name(con));
6309 }
6311 /*
6312 * errno values
6313 * EBUSY - can't lock
6314 * ENOENT - no existence of context
6315 */
6316 int ast_context_add_switch(const char *context, const char *sw, const char *data, int eval, const char *registrar)
6317 {
6324 }
6326 }
6328 /*
6329 * errno values
6330 * ENOMEM - out of memory
6331 * EBUSY - can't lock
6332 * EEXIST - already included
6333 * EINVAL - there is no existence of context for inclusion
6334 */
6337 {
6347 length++;
6349 /* allocate new sw structure ... */
6352 /* ... fill in this structure ... */
6363 p++;
6364 }
6368 /* ... try to lock this context ... */
6371 /* ... go to last sw and check if context is already swd too... */
6378 }
6379 }
6381 /* ... sw new context into context list, unlock, return */
6384 ast_verb(3, "Including switch '%s/%s' in context '%s'\n", new_sw->name, new_sw->data, ast_get_context_name(con));
6389 }
6391 /*
6392 * EBUSY - can't lock
6393 * ENOENT - there is not context existence
6394 */
6395 int ast_context_remove_ignorepat(const char *context, const char *ignorepat, const char *registrar)
6396 {
6403 }
6405 }
6407 int ast_context_remove_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar)
6408 {
6422 }
6425 }
6427 }
6432 }
6434 /*
6435 * EBUSY - can't lock
6436 * ENOENT - there is no existence of context
6437 */
6439 {
6446 }
6448 }
6450 int ast_context_add_ignorepat2(struct ast_context *con, const char *value, const char *registrar)
6451 {
6458 /* The cast to char * is because we need to write the initial value.
6459 * The field is not supposed to be modified otherwise
6460 */
6468 /* Already there */
6472 }
6473 }
6476 else
6481 }
6484 {
6491 }
6492 }
6495 }
6497 /*
6498 * EBUSY - can't lock
6499 * ENOENT - no existence of context
6500 *
6501 */
6505 {
6513 }
6516 }
6518 int ast_explicit_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
6519 {
6531 /* see flag description in channel.h for explanation */
6534 }
6539 }
6541 int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
6542 {
6551 /* In order to do it when the channel doesn't really exist within
6552 the PBX, we have to make a new channel, masquerade, and start the PBX
6553 at the new location */
6554 struct ast_channel *tmpchan = ast_channel_alloc(0, chan->_state, 0, 0, chan->accountcode, chan->exten, chan->context, chan->amaflags, "AsyncGoto/%s", chan->name);
6561 }
6562 /* Make formats okay */
6565 /* Setup proper location */
6569 /* Masquerade into temp channel */
6572 /* Grab the locks and get going */
6576 /* Start the PBX going on our stolen channel */
6581 }
6582 }
6583 }
6586 }
6588 int ast_async_goto_by_name(const char *channame, const char *context, const char *exten, int priority)
6589 {
6597 }
6599 }
6601 /*! \brief copy a string skipping whitespace */
6603 {
6609 /* otherwise exten => [a-b],1,... doesn't work */
6610 /* case '-': */
6611 /* Ignore */
6615 dst++;
6616 }
6617 src++;
6618 count++;
6619 }
6623 }
6625 /*!
6626 * \brief add the extension in the priority chain.
6627 * \retval 0 on success.
6628 * \retval -1 on failure.
6629 */
6632 {
6639 }
6645 }
6648 }
6650 /* Can't have something exactly the same. Is this a
6651 replacement? If so, replace, otherwise, bonk. */
6653 ast_log(LOG_WARNING, "Unable to register extension '%s', priority %d in '%s', already in use\n", tmp->exten, tmp->priority, con->name);
6656 /* if you free this, null it out */
6658 }
6662 }
6663 /* we are replacing e, so copy the link fields and then update
6664 * whoever pointed to e to point to us
6665 */
6673 }
6678 }
6689 }
6692 }
6697 /* The pattern trie points to this exten; replace the pointer,
6698 and all will be well */
6703 ast_log(LOG_ERROR,"Trying to delete an exten from a context, but the pattern tree node returned isn't an extension\n");
6704 }
6705 }
6716 }
6719 }
6724 /* The pattern trie points to this exten; replace the pointer,
6725 and all will be well */
6730 ast_log(LOG_ERROR,"Trying to delete an exten from a context, but the pattern tree node returned isn't an extension\n");
6731 }
6732 }
6733 }
6736 /* Destroy the old one */
6746 }
6757 }
6762 else
6765 }
6766 /* And immediately return success. */
6769 }
6771 }
6773 /*! \brief
6774 * Main interface to add extensions to the list for out context.
6775 *
6776 * We sort extensions in order of matching preference, so that we can
6777 * stop the search as soon as we find a suitable match.
6778 * This ordering also takes care of wildcards such as '.' (meaning
6779 * "one or more of any character") and '!' (which is 'earlymatch',
6780 * meaning "zero or more of any character" but also impacts the
6781 * return value from CANMATCH and EARLYMATCH.
6782 *
6783 * The extension match rules defined in the devmeeting 2006.05.05 are
6784 * quite simple: WE SELECT THE LONGEST MATCH.
6785 * In detail, "longest" means the number of matched characters in
6786 * the extension. In case of ties (e.g. _XXX and 333) in the length
6787 * of a pattern, we give priority to entries with the smallest cardinality
6788 * (e.g, [5-9] comes before [2-8] before the former has only 5 elements,
6789 * while the latter has 7, etc.
6790 * In case of same cardinality, the first element in the range counts.
6791 * If we still have a tie, any final '!' will make this as a possibly
6792 * less specific pattern.
6793 *
6794 * EBUSY - can't lock
6795 * EEXIST - extension with the same priority exist and no replace is set
6796 *
6797 */
6802 {
6803 /*
6804 * Sort extensions (or patterns) according to the rules indicated above.
6805 * These are implemented by the function ext_cmp()).
6806 * All priorities for the same ext/pattern/cid are kept in a list,
6807 * using the 'peer' field as a link field..
6808 */
6818 ast_log(LOG_ERROR,"You have to be kidding-- add exten '' to context %s? Figure out a name and call me back. Action ignored.\n",
6821 }
6823 /* If we are adding a hint evalulate in variables and global variables */
6827 /* Start out with regular variables */
6832 /* Move on to global variables if they exist */
6837 }
6839 }
6848 else
6851 /* Be optimistic: Build the extension structure first */
6858 /* use p as dst in assignments, as the fields are const char * */
6864 }
6875 }
6885 if (con->pattern_tree) { /* usually, on initial load, the pattern_tree isn't formed until the first find_exten; so if we are adding
6886 an extension, and the trie exists, then we need to incrementally add this pattern to it. */
6893 /* hmmm, not in the trie; */
6896 }
6897 }
6908 else
6910 }
6913 }
6920 }
6922 /*
6923 * not an exact match, this is the first entry with this pattern,
6924 * so insert in the main list right before 'e' (if any)
6925 */
6930 hashtab_compare_exten_numbers,
6931 ast_hashtab_resize_java,
6932 ast_hashtab_newsize_java,
6933 hashtab_hash_priority,
6936 hashtab_compare_exten_labels,
6937 ast_hashtab_resize_java,
6938 ast_hashtab_newsize_java,
6939 hashtab_hash_labels,
6943 }
6948 hashtab_compare_extens,
6949 ast_hashtab_resize_java,
6950 ast_hashtab_newsize_java,
6951 hashtab_hash_extens,
6955 hashtab_compare_exten_numbers,
6956 ast_hashtab_resize_java,
6957 ast_hashtab_newsize_java,
6958 hashtab_hash_priority,
6961 hashtab_compare_exten_labels,
6962 ast_hashtab_resize_java,
6963 ast_hashtab_newsize_java,
6964 hashtab_hash_labels,
6968 }
6971 }
6976 }
6984 }
6985 }
6993 }
6996 }
6999 pthread_t p;
7007 };
7010 {
7032 }
7033 }
7035 }
7051 /* Run the PBX */
7055 /* PBX will have taken care of this */
7057 }
7058 }
7059 }
7064 }
7066 /*!
7067 * \brief Function to post an empty cdr after a spool call fails.
7068 * \note This function posts an empty cdr for a failed spool call
7069 */
7071 {
7072 /* allocate a channel */
7079 /* allocation of the cdr failed */
7082 }
7084 /* allocation of the cdr was successful */
7093 }
7095 int ast_pbx_outgoing_exten(const char *type, int format, void *data, int timeout, const char *context, const char *exten, int priority, int *reason, int synchronous, const char *cid_num, const char *cid_name, struct ast_variable *vars, const char *account, struct ast_channel **channel)
7096 {
7117 }
7133 }
7140 }
7143 }
7145 }
7150 /* here we update the status of the call, which sould be busy.
7151 * if that fails then we set the status to failed */
7154 }
7159 }
7162 }
7163 }
7167 * update the cdr with the failed message */
7172 }
7173 }
7175 /* create a fake channel and execute the "failed" extension (if it exists) within the requested context */
7176 /* check if "failed" exists */
7192 }
7194 }
7195 }
7196 }
7201 }
7207 }
7212 }
7226 }
7230 }
7232 }
7233 outgoing_exten_cleanup:
7236 }
7242 pthread_t t;
7243 };
7245 /*! \brief run the application and free the descriptor once done */
7247 {
7259 }
7261 int ast_pbx_outgoing_app(const char *type, int format, void *data, int timeout, const char *app, const char *appdata, int *reason, int synchronous, const char *cid_num, const char *cid_name, struct ast_variable *vars, const char *account, struct ast_channel **locked_channel)
7262 {
7277 }
7303 ast_log(LOG_WARNING, "Unable to spawn execute thread on %s: %s\n", chan->name, strerror(errno));
7312 }
7313 }
7314 }
7318 /* here we update the status of the call, which sould be busy.
7319 * if that fails then we set the status to failed */
7322 }
7324 }
7325 }
7329 * update the cdr with the failed message */
7334 }
7335 }
7336 }
7343 }
7349 }
7358 /* Start a new thread, and get something handling this channel. */
7372 }
7374 }
7375 outgoing_app_cleanup:
7378 }
7380 /* this is the guts of destroying a context --
7381 freeing up the structure, traversing and destroying the
7382 extensions, switches, ignorepats, includes, etc. etc. */
7385 {
7396 }
7401 }
7405 /* destroy the hash tabs */
7408 }
7409 /* and destroy the pattern tree */
7420 }
7424 }
7428 }
7431 void __ast_context_destroy(struct ast_context *list, struct ast_hashtab *contexttab, struct ast_context *con, const char *registrar)
7432 {
7438 /* The following code used to skip forward to the next
7439 context with matching registrar, but this didn't
7440 make sense; individual priorities registrar'd to
7441 the matching registrar could occur in any context! */
7448 }
7449 }
7450 }
7457 /* then search thru and remove any extens that match registrar. */
7464 /* remove any ignorepats whose registrar matches */
7476 }
7477 }
7479 }
7480 /* remove any includes whose registrar matches */
7484 /* remove from list */
7487 /* free include */
7492 /* free include */
7495 }
7496 }
7498 }
7499 /* remove any switches whose registrar matches */
7504 }
7505 }
7506 AST_LIST_TRAVERSE_SAFE_END
7515 }
7517 tmp->name, prio_item->exten, prio_item->priority, registrar, con? con->name : "<nil>", con, con? con->root_table: NULL);
7518 /* set matchcid to 1 to insure we get a direct match, and NULL registrar to make sure no wildcarding is done */
7519 ast_context_remove_extension_callerid2(tmp, prio_item->exten, prio_item->priority, prio_item->cidmatch, 1, NULL, 1);
7520 }
7522 }
7524 }
7526 /* delete the context if it's registrar matches, is empty, has refcount of 1, */
7527 /* it's not empty, if it has includes, ignorepats, or switches that are registered from
7528 another registrar. It's not empty if there are any extensions */
7529 if (strcmp(tmp->registrar, registrar) == 0 && tmp->refcount < 2 && !tmp->root && !tmp->ignorepats && !tmp->includes && AST_LIST_EMPTY(&tmp->alts)) {
7536 else
7538 /* Okay, now we're safe to let it go -- in a sense, we were
7539 ready to let it go as soon as we locked it. */
7548 }
7557 else
7559 /* Okay, now we're safe to let it go -- in a sense, we were
7560 ready to let it go as soon as we locked it. */
7563 }
7565 /* if we have a specific match, we are done, otherwise continue */
7567 }
7568 }
7571 {
7575 }
7578 {
7597 }
7599 /*!
7600 * \ingroup applications
7601 */
7603 {
7606 }
7608 /*!
7609 * \ingroup applications
7610 */
7612 {
7615 }
7617 /*!
7618 * \ingroup applications
7619 */
7621 {
7624 }
7626 /*!
7627 * \ingroup applications
7628 */
7630 {
7632 /* Don't change state of an UP channel, just indicate
7633 busy in audio */
7638 }
7640 /*!
7641 * \ingroup applications
7642 */
7644 {
7646 /* Don't change state of an UP channel, just indicate
7647 congestion in audio */
7652 }
7654 /*!
7655 * \ingroup applications
7656 */
7658 {
7666 }
7669 }
7672 {
7674 }
7677 {
7681 /* Some channels can receive DTMF in unanswered state; some cannot */
7684 }
7686 /* If the channel is hungup, stop waiting */
7691 }
7694 }
7701 });
7703 /*!
7704 * \ingroup applications
7705 */
7707 {
7714 }
7719 }
7721 /*!
7722 * \ingroup applications
7723 */
7725 {
7726 /* Copy the AMA Flags as specified */
7729 }
7731 /*!
7732 * \ingroup applications
7733 */
7735 {
7743 }
7749 }
7752 }
7756 }
7759 }
7761 /*!
7762 * \ingroup applications
7763 */
7765 {
7770 ast_log(LOG_WARNING, "GotoIfTime requires an argument:\n <time range>,<days of week>,<days of month>,<months>?'labeliftrue':'labeliffalse'\n");
7772 }
7776 /* Separate the Goto path */
7781 /* struct ast_include include contained garbage here, fixed by zeroing it on get_timerange */
7784 else
7790 }
7793 }
7795 /*!
7796 * \ingroup applications
7797 */
7799 {
7803 static const char *usage = "ExecIfTime requires an argument:\n <time range>,<days of week>,<days of month>,<months>?<appname>[(<appargs>)]";
7808 }
7816 }
7821 }
7826 /* now split appname(appargs) */
7832 else
7834 }
7842 }
7843 }
7845 /*!
7846 * \ingroup applications
7847 */
7849 {
7853 /* Wait for "n" seconds */
7857 }
7859 }
7861 /*!
7862 * \ingroup applications
7863 */
7865 {
7874 );
7893 else
7895 }
7896 /* Wait for "n" seconds */
7901 else
7906 if (ast_exists_extension(chan, chan->context, chan->exten, chan->priority + 1, chan->cid.cid_num)) {
7917 }
7918 }
7926 }
7928 /*!
7929 * \ingroup applications
7930 */
7932 {
7942 );
7947 }
7964 else
7966 }
7968 /* Answer if need be */
7974 }
7975 }
7982 /* Stream the list of files */
7989 }
7996 }
7998 }
7999 }
8005 }
8006 done:
8009 }
8011 /*! Goto
8012 * \ingroup applications
8013 */
8015 {
8020 }
8024 {
8039 /* && !ast_strlen_zero(var) && !ast_strlen_zero(val) */
8040 ) {
8045 total++;
8048 }
8053 }
8056 {
8068 }
8079 }
8080 }
8085 }
8091 }
8094 {
8104 }
8112 }
8119 }
8123 else
8125 }
8128 {
8138 }
8146 }
8148 /* For comparison purposes, we have to strip leading underscores */
8150 nametail++;
8152 nametail++;
8153 }
8157 /* there is already such a variable, delete it */
8161 }
8162 }
8176 }
8180 else
8182 }
8185 {
8190 }
8195 }
8201 ast_log(LOG_WARNING, "Please avoid unnecessary spaces on variables as it may lead to unexpected results ('%s' set to '%s').\n", name, mydata);
8205 }
8208 {
8213 );
8217 );
8222 }
8232 ast_log(LOG_WARNING, "Please avoid unnecessary spaces on variables as it may lead to unexpected results ('%s' set to '%s').\n", pair.name, pair.value);
8236 ast_log(LOG_WARNING, "MSet: ignoring entry '%s' with no '=' (in %s@%s:%d\n", pair.name, chan->exten, chan->context, chan->priority);
8237 }
8238 }
8241 }
8244 {
8254 }
8257 ast_log(LOG_WARNING, "ImportVar is deprecated. Please use Set(varname=${IMPORT(channel,variable)}) instead.\n");
8259 }
8271 }
8273 }
8275 }
8278 }
8281 {
8283 }
8286 {
8293 }
8296 {
8304 }
8305 }
8308 {
8315 }
8326 }
8329 }
8332 {
8340 }
8349 }
8350 }
8354 }
8357 }
8360 {
8366 }
8369 {
8375 }
8378 {
8384 }
8387 {
8395 }
8402 }
8403 }
8406 {
8409 /* Initialize the PBX */
8413 }
8419 /* Register builtin applications */
8422 if (ast_register_application2(builtins[x].name, builtins[x].execute, builtins[x].synopsis, builtins[x].description, NULL)) {
8425 }
8426 }
8428 /* Register manager application */
8429 ast_manager_register2("ShowDialPlan", EVENT_FLAG_CONFIG | EVENT_FLAG_REPORTING, manager_show_dialplan, "List dialplan", mandescr_show_dialplan);
8431 if (!(device_state_sub = ast_event_subscribe(AST_EVENT_DEVICE_STATE_CHANGE, device_state_cb, NULL,
8432 AST_EVENT_IE_END))) {
8434 }
8437 }
8441 {
8443 }
8445 /*
8446 * Lock context list functions ...
8447 */
8449 {
8454 }
8457 {
8459 }
8462 {
8464 }
8466 /*
8467 * Lock context ...
8468 */
8470 {
8472 }
8475 {
8477 }
8480 {
8482 }
8484 /*
8485 * Name functions ...
8486 */
8488 {
8490 }
8493 {
8495 }
8498 {
8500 }
8503 {
8505 }
8508 {
8510 }
8513 {
8515 }
8518 {
8520 }
8522 /*
8523 * Registrar info functions ...
8524 */
8526 {
8528 }
8531 {
8533 }
8536 {
8538 }
8541 {
8543 }
8546 {
8548 }
8551 {
8553 }
8556 {
8558 }
8561 {
8563 }
8566 {
8568 }
8571 {
8573 }
8576 {
8578 }
8581 {
8583 }
8585 /*
8586 * Walking functions ...
8587 */
8589 {
8591 }
8595 {
8598 else
8600 }
8604 {
8607 else
8609 }
8613 {
8615 }
8619 {
8622 else
8624 }
8628 {
8631 else
8633 }
8636 {
8648 }
8651 }
8654 static int __ast_goto_if_exists(struct ast_channel *chan, const char *context, const char *exten, int priority, int async)
8655 {
8656 int (*goto_func)(struct ast_channel *chan, const char *context, const char *exten, int priority);
8669 else
8671 }
8673 int ast_goto_if_exists(struct ast_channel *chan, const char* context, const char *exten, int priority)
8674 {
8676 }
8678 int ast_async_goto_if_exists(struct ast_channel *chan, const char * context, const char *exten, int priority)
8679 {
8681 }
8684 {
8693 }
8706 }
8709 pri++;
8712 pri++;
8713 }
8715 if ((ipri = ast_findlabel_extension(chan, context ? context : chan->context, exten ? exten : chan->exten,
8721 }
8722 /* At this point we have a priority and maybe an extension and a context */
8729 else
8734 }
8737 {
8739 }
8742 {
8744 }