8ae0879876cabff2e8176c871386a51358e58b05
[asterisk/asterisk.git] / main / pbx.c
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  */
18
19 /*! \file
20  *
21  * \brief Core PBX routines.
22  *
23  * \author Mark Spencer <markster@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/_private.h"
31 #include "asterisk/paths.h"     /* use ast_config_AST_SYSTEM_NAME */
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
41
42 #include "asterisk/lock.h"
43 #include "asterisk/cli.h"
44 #include "asterisk/pbx.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/file.h"
47 #include "asterisk/callerid.h"
48 #include "asterisk/cdr.h"
49 #include "asterisk/config.h"
50 #include "asterisk/term.h"
51 #include "asterisk/time.h"
52 #include "asterisk/manager.h"
53 #include "asterisk/ast_expr.h"
54 #include "asterisk/linkedlists.h"
55 #define SAY_STUBS       /* generate declarations and stubs for say methods */
56 #include "asterisk/say.h"
57 #include "asterisk/utils.h"
58 #include "asterisk/causes.h"
59 #include "asterisk/musiconhold.h"
60 #include "asterisk/app.h"
61 #include "asterisk/devicestate.h"
62 #include "asterisk/event.h"
63 #include "asterisk/hashtab.h"
64 #include "asterisk/module.h"
65 #include "asterisk/indications.h"
66 #include "asterisk/taskprocessor.h"
67 #include "asterisk/xml.h"
68
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  */
89
90 /*** DOCUMENTATION
91         <application name="Answer" language="en_US">
92                 <synopsis>
93                         Answer a channel if ringing.
94                 </synopsis>
95                 <syntax>
96                         <parameter name="delay">
97                                 <para>Asterisk will wait this number of milliseconds before returning to
98                                 the dialplan after answering the call.</para>
99                         </parameter>
100                 </syntax>
101                 <description>
102                         <para>If the call has not been answered, this application will
103                         answer it. Otherwise, it has no effect on the call.</para>
104                 </description>
105         </application>
106         <application name="BackGround" language="en_US">
107                 <synopsis>
108                         Play an audio file while waiting for digits of an extension to go to.
109                 </synopsis>
110                 <syntax>
111                         <parameter name="filenames" required="true" argsep="&amp;">
112                                 <argument name="filename1" required="true" />
113                                 <argument name="filename2" multiple="true" />
114                         </parameter>
115                         <parameter name="options">
116                                 <optionlist>
117                                         <option name="s">
118                                                 <para>Causes the playback of the message to be skipped
119                                                 if the channel is not in the <literal>up</literal> state (i.e. it
120                                                 hasn't been answered yet). If this happens, the
121                                                 application will return immediately.</para>
122                                         </option>
123                                         <option name="n">
124                                                 <para>Don't answer the channel before playing the files.</para>
125                                         </option>
126                                         <option name="m">
127                                                 <para>Only break if a digit hit matches a one digit
128                                                 extension in the destination context.</para>
129                                         </option>
130                                 </optionlist>
131                         </parameter>
132                         <parameter name="langoverride">
133                                 <para>Explicitly specifies which language to attempt to use for the requested sound files.</para>
134                         </parameter>
135                         <parameter name="context">
136                                 <para>This is the dialplan context that this application will use when exiting
137                                 to a dialed extension.</para>
138                         </parameter>    
139                 </syntax>
140                 <description>
141                         <para>This application will play the given list of files <emphasis>(do not put extension)</emphasis>
142                         while waiting for an extension to be dialed by the calling channel. To continue waiting
143                         for digits after this application has finished playing files, the <literal>WaitExten</literal>
144                         application should be used.</para>
145                         <para>If one of the requested sound files does not exist, call processing will be terminated.</para>
146                         <para>This application sets the following channel variable upon completion:</para>
147                         <variablelist>
148                                 <variable name="BACKGROUNDSTATUS">
149                                         <para>The status of the background attempt as a text string.</para>
150                                         <value name="SUCCESS" />
151                                         <value name="FAILED" />
152                                 </variable>
153                         </variablelist>
154                 </description>
155                 <see-also>
156                         <ref type="application">Playback</ref>
157                 </see-also>
158         </application>
159         <application name="Busy" language="en_US">
160                 <synopsis>
161                         Indicate the Busy condition.
162                 </synopsis>
163                 <syntax>
164                         <parameter name="timeout">
165                                 <para>If specified, the calling channel will be hung up after the specified number of seconds.
166                                 Otherwise, this application will wait until the calling channel hangs up.</para>
167                         </parameter>
168                 </syntax>
169                 <description>
170                         <para>This application will indicate the busy condition to the calling channel.</para>
171                 </description>
172         </application>
173         <application name="Congestion" language="en_US">
174                 <synopsis>
175                         Indicate the Congestion condition.
176                 </synopsis>
177                 <syntax>
178                         <parameter name="timeout">
179                                 <para>If specified, the calling channel will be hung up after the specified number of seconds.
180                                 Otherwise, this application will wait until the calling channel hangs up.</para>
181                         </parameter>
182                 </syntax>
183                 <description>
184                         <para>This application will indicate the congestion condition to the calling channel.</para>
185                 </description>
186         </application>
187         <application name="ExecIfTime" language="en_US">
188                 <synopsis>
189                         Conditional application execution based on the current time.
190                 </synopsis>
191                 <syntax argsep="?">
192                         <parameter name="day_condition" required="true">
193                                 <argument name="times" required="true" />
194                                 <argument name="weekdays" required="true" />
195                                 <argument name="mdays" required="true" />
196                                 <argument name="months" required="true" />
197                         </parameter>
198                         <parameter name="appname" required="true" hasparams="optional">
199                                 <argument name="appargs" required="true" />
200                         </parameter>
201                 </syntax>
202                 <description>
203                         <para>This application will execute the specified dialplan application, with optional
204                         arguments, if the current time matches the given time specification.</para>
205                 </description>
206         </application>
207         <application name="Goto" language="en_US">
208                 <synopsis>
209                         Jump to a particular priority, extension, or context.
210                 </synopsis>
211                 <syntax>
212                         <parameter name="context" />
213                         <parameter name="extensions" />
214                         <parameter name="priority" required="true" />
215                 </syntax>
216                 <description>
217                         <para>This application will set the current context, extension, and priority in the channel structure.
218                         After it completes, the pbx engine will continue dialplan execution at the specified location.
219                         If no specific <replaceable>extension</replaceable>, or <replaceable>extension</replaceable> and
220                         <replaceable>context</replaceable>, are specified, then this application will
221                         just set the specified <replaceable>priority</replaceable> of the current extension.</para>
222                         <para>At least a <replaceable>priority</replaceable> is required as an argument, or the goto will
223                         return a <literal>-1</literal>, and the channel and call will be terminated.</para>
224                         <para>If the location that is put into the channel information is bogus, and asterisk cannot
225                         find that location in the dialplan, then the execution engine will try to find and execute the code in
226                         the <literal>i</literal> (invalid) extension in the current context. If that does not exist, it will try to execute the
227                         <literal>h</literal> extension. If either or neither the <literal>h</literal> or <literal>i</literal> extensions
228                         have been defined, the channel is hung up, and the execution of instructions on the channel is terminated.
229                         What this means is that, for example, you specify a context that does not exist, then
230                         it will not be possible to find the <literal>h</literal> or <literal>i</literal> extensions,
231                         and the call will terminate!</para>
232                 </description>
233         </application>
234         <application name="GotoIf" language="en_US">
235                 <synopsis>
236                         Conditional goto.
237                 </synopsis>
238                 <syntax argsep="?">
239                         <parameter name="condition" required="true" />
240                         <parameter name="destination" required="true" argsep=":">
241                                 <argument name="labeliftrue">
242                                         <para>Continue at <replaceable>labeliftrue</replaceable> if the condition is true.</para>
243                                 </argument>
244                                 <argument name="labeliffalse">
245                                         <para>Continue at <replaceable>labeliffalse</replaceable> if the condition is false.</para>
246                                 </argument>
247                         </parameter>
248                 </syntax>
249                 <description>
250                         <para>This application will set the current context, extension, and priority in the channel structure
251                         based on the evaluation of the given condition. After this application completes, the
252                         pbx engine will continue dialplan execution at the specified location in the dialplan.
253                         The labels are specified with the same syntax as used within the Goto application.
254                         If the label chosen by the condition is omitted, no jump is performed, and the execution passes to the
255                         next instruction. If the target location is bogus, and does not exist, the execution engine will try
256                         to find and execute the code in the <literal>i</literal> (invalid) extension in the current context.
257                         If that does not exist, it will try to execute the <literal>h</literal> extension.
258                         If either or neither the <literal>h</literal> or <literal>i</literal> extensions have been defined,
259                         the channel is hung up, and the execution of instructions on the channel is terminated.
260                         Remember that this command can set the current context, and if the context specified
261                         does not exist, then it will not be able to find any 'h' or 'i' extensions there, and
262                         the channel and call will both be terminated!.</para>
263                 </description>
264         </application>
265         <application name="GotoIfTime" language="en_US">
266                 <synopsis>
267                         Conditional Goto based on the current time.
268                 </synopsis>
269                 <syntax argsep="?">
270                         <parameter name="condition" required="true">
271                                 <argument name="times" required="true" />
272                                 <argument name="weekdays" required="true" />
273                                 <argument name="mdays" required="true" />
274                                 <argument name="months" required="true" />
275                         </parameter>
276                         <parameter name="destination" required="true" argsep=":">
277                                 <argument name="labeliftrue" />
278                                 <argument name="labeliffalse" />
279                         </parameter>
280                 </syntax>
281                 <description>
282                         <para>This application will set the context, extension, and priority in the channel structure
283                         based on the evaluation of the given time specification. After this application completes,
284                         the pbx engine will continue dialplan execution at the specified location in the dialplan.
285                         If the current time is within the given time specification, the channel will continue at
286                         <replaceable>labeliftrue</replaceable>. Otherwise the channel will continue at <replaceable>labeliffalse</replaceable>.
287                         If the label chosen by the condition is omitted, no jump is performed, and execution passes to the next
288                         instruction. If the target jump location is bogus, the same actions would be taken as for <literal>Goto</literal>.
289                         Further information on the time specification can be found in examples
290                         illustrating how to do time-based context includes in the dialplan.</para>
291                 </description>
292         </application>
293         <application name="ImportVar" language="en_US">
294                 <synopsis>
295                         Import a variable from a channel into a new variable.
296                 </synopsis>
297                 <syntax argsep="=">
298                         <parameter name="newvar" required="true" />
299                         <parameter name="vardata" required="true">
300                                 <argument name="channelname" required="true" />
301                                 <argument name="variable" required="true" />
302                         </parameter>
303                 </syntax>
304                 <description>
305                         <para>This application imports a <replaceable>variable</replaceable> from the specified
306                         <replaceable>channel</replaceable> (as opposed to the current one) and stores it as a variable
307                         (<replaceable>newvar</replaceable>) in the current channel (the channel that is calling this
308                         application). Variables created by this application have the same inheritance properties as those
309                         created with the <literal>Set</literal> application.</para>
310                 </description>
311                 <see-also>
312                         <ref type="application">Set</ref>
313                 </see-also>
314         </application>
315         <application name="Hangup" language="en_US">
316                 <synopsis>
317                         Hang up the calling channel.
318                 </synopsis>
319                 <syntax>
320                         <parameter name="causecode">
321                                 <para>If a <replaceable>causecode</replaceable> is given the channel's
322                                 hangup cause will be set to the given value.</para>
323                         </parameter>
324                 </syntax>
325                 <description>
326                         <para>This application will hang up the calling channel.</para>
327                 </description>
328         </application>
329         <application name="Incomplete" language="en_US">
330                 <synopsis>
331                         Returns AST_PBX_INCOMPLETE value.
332                 </synopsis>
333                 <syntax>
334                         <parameter name="n">
335                                 <para>If specified, then Incomplete will not attempt to answer the channel first.</para>
336                                 <note><para>Most channel types need to be in Answer state in order to receive DTMF.</para></note>
337                         </parameter>
338                 </syntax>
339                 <description>
340                         <para>Signals the PBX routines that the previous matched extension is incomplete
341                         and that further input should be allowed before matching can be considered
342                         to be complete.  Can be used within a pattern match when certain criteria warrants
343                         a longer match.</para>
344                         
345                 </description>
346         </application>
347         <application name="KeepAlive" language="en_US">
348                 <synopsis>
349                         Returns AST_PBX_KEEPALIVE value.
350                 </synopsis>
351                 <syntax />
352                 <description>
353                         <para>This application is chiefly meant for internal use with Gosubs. Please do not run
354                         it alone from the dialplan!</para>
355                 </description>
356         </application>
357         <application name="NoOp" language="en_US">
358                 <synopsis>
359                         Do Nothing (No Operation).
360                 </synopsis>
361                 <syntax>
362                         <parameter name="text">
363                                 <para>Any text provided can be viewed at the Asterisk CLI.</para>
364                         </parameter>
365                 </syntax>
366                 <description>
367                         <para>This application does nothing. However, it is useful for debugging purposes.</para>
368                         <para>This method can be used to see the evaluations of variables or functions without having any effect.</para>
369                 </description>
370                 <see-also>
371                         <ref type="application">Verbose</ref>
372                 </see-also>
373         </application>
374         <application name="Proceeding" language="en_US">
375                 <synopsis>
376                         Indicate proceeding.
377                 </synopsis>
378                 <syntax />
379                 <description>
380                         <para>This application will request that a proceeding message be provided to the calling channel.</para>
381                 </description>
382         </application>
383         <application name="Progress" language="en_US">
384                 <synopsis>
385                         Indicate progress.
386                 </synopsis>
387                 <syntax />
388                 <description>
389                         <para>This application will request that in-band progress information be provided to the calling channel.</para>
390                 </description>
391         </application>
392         <application name="RaiseException" language="en_US">
393                 <synopsis>
394                         Handle an exceptional condition.
395                 </synopsis>
396                 <syntax>
397                         <parameter name="reason" required="true" />
398                 </syntax>
399                 <description>
400                         <para>This application will jump to the <literal>e</literal> extension in the current context, setting the
401                         dialplan function EXCEPTION(). If the <literal>e</literal> extension does not exist, the call will hangup.</para>
402                 </description>
403         </application>
404         <application name="ResetCDR" language="en_US">
405                 <synopsis>
406                         Resets the Call Data Record.
407                 </synopsis>
408                 <syntax>
409                         <parameter name="options">
410                                 <optionlist>
411                                         <option name="w">
412                                                 <para>Store the current CDR record before resetting it.</para>
413                                         </option>
414                                         <option name="a">
415                                                 <para>Store any stacked records.</para>
416                                         </option>
417                                         <option name="v">
418                                                 <para>Save CDR variables.</para>
419                                         </option>
420                                         <option name="e">
421                                                 <para>Enable CDR only (negate effects of NoCDR).</para>
422                                         </option>
423                                 </optionlist>
424                         </parameter>
425                 </syntax>
426                 <description>
427                         <para>This application causes the Call Data Record to be reset.</para>
428                 </description>
429         </application>
430         <application name="Ringing" language="en_US">
431                 <synopsis>
432                         Indicate ringing tone.
433                 </synopsis>
434                 <syntax />
435                 <description>
436                         <para>This application will request that the channel indicate a ringing tone to the user.</para>
437                 </description>
438         </application>
439         <application name="SayAlpha" language="en_US">
440                 <synopsis>
441                         Say Alpha.
442                 </synopsis>
443                 <syntax>
444                         <parameter name="string" required="true" />
445                 </syntax>
446                 <description>
447                         <para>This application will play the sounds that correspond to the letters of the
448                         given <replaceable>string</replaceable>.</para>
449                 </description>
450         </application>
451         <application name="SayDigits" language="en_US">
452                 <synopsis>
453                         Say Digits.
454                 </synopsis>
455                 <syntax>
456                         <parameter name="digits" required="true" />
457                 </syntax>
458                 <description>
459                         <para>This application will play the sounds that correspond to the digits of
460                         the given number. This will use the language that is currently set for the channel.</para>
461                 </description>
462         </application>
463         <application name="SayNumber" language="en_US">
464                 <synopsis>
465                         Say Number.
466                 </synopsis>
467                 <syntax>
468                         <parameter name="digits" required="true" />
469                         <parameter name="gender" />
470                 </syntax>
471                 <description>
472                         <para>This application will play the sounds that correspond to the given <replaceable>digits</replaceable>.
473                         Optionally, a <replaceable>gender</replaceable> may be specified. This will use the language that is currently
474                         set for the channel. See the LANGUAGE() function for more information on setting the language for the channel.</para>
475                 </description>
476         </application>
477         <application name="SayPhonetic" language="en_US">
478                 <synopsis>
479                         Say Phonetic.
480                 </synopsis>
481                 <syntax>
482                         <parameter name="string" required="true" />
483                 </syntax>
484                 <description>
485                         <para>This application will play the sounds from the phonetic alphabet that correspond to the
486                         letters in the given <replaceable>string</replaceable>.</para>
487                 </description>
488         </application>
489         <application name="Set" language="en_US">
490                 <synopsis>
491                         Set channel variable or function value.
492                 </synopsis>
493                 <syntax argsep="=">
494                         <parameter name="name" required="true" />
495                         <parameter name="value" required="true" />
496                 </syntax>
497                 <description>
498                         <para>This function can be used to set the value of channel variables or dialplan functions.
499                         When setting variables, if the variable name is prefixed with <literal>_</literal>,
500                         the variable will be inherited into channels created from the current channel.
501                         If the variable name is prefixed with <literal>__</literal>, the variable will be
502                         inherited into channels created from the current channel and all children channels.</para>
503                         <note><para>If (and only if), in <filename>/etc/asterisk/asterisk.conf</filename>, you have
504                         a <literal>[compat]</literal> category, and you have <literal>app_set = 1.6</literal> under that,then
505                         the behavior of this app changes, and does not strip surrounding quotes from the right hand side as
506                         it did previously in 1.4. The <literal>app_set = 1.6</literal> is only inserted if <literal>make samples</literal>
507                         is executed, or if users insert this by hand into the <filename>asterisk.conf</filename> file.
508                         The advantages of not stripping out quoting, and not caring about the separator characters (comma and vertical bar)
509                         were sufficient to make these changes in 1.6. Confusion about how many backslashes would be needed to properly
510                         protect separators and quotes in various database access strings has been greatly
511                         reduced by these changes.</para></note>
512                 </description>
513         </application>
514         <application name="MSet" language="en_US">
515                 <synopsis>
516                         Set channel variable(s) or function value(s).
517                 </synopsis>
518                 <syntax>
519                         <parameter name="set1" required="true" argsep="=">
520                                 <argument name="name1" required="true" />
521                                 <argument name="value1" required="true" />
522                         </parameter>
523                         <parameter name="set2" multiple="true" argsep="=">
524                                 <argument name="name2" required="true" />
525                                 <argument name="value2" required="true" />
526                         </parameter>
527                 </syntax>
528                 <description>
529                         <para>This function can be used to set the value of channel variables or dialplan functions.
530                         When setting variables, if the variable name is prefixed with <literal>_</literal>,
531                         the variable will be inherited into channels created from the current channel
532                         If the variable name is prefixed with <literal>__</literal>, the variable will be
533                         inherited into channels created from the current channel and all children channels.
534                         MSet behaves in a similar fashion to the way Set worked in 1.2/1.4 and is thus
535                         prone to doing things that you may not expect. For example, it strips surrounding
536                         double-quotes from the right-hand side (value). If you need to put a separator
537                         character (comma or vert-bar), you will need to escape them by inserting a backslash
538                         before them. Avoid its use if possible.</para>
539                 </description>
540         </application>
541         <application name="SetAMAFlags" language="en_US">
542                 <synopsis>
543                         Set the AMA Flags.
544                 </synopsis>
545                 <syntax>
546                         <parameter name="flag" />
547                 </syntax>
548                 <description>
549                         <para>This application will set the channel's AMA Flags for billing purposes.</para>
550                 </description>
551         </application>
552         <application name="Wait" language="en_US">
553                 <synopsis>
554                         Waits for some time.
555                 </synopsis>
556                 <syntax>
557                         <parameter name="seconds" required="true">
558                                 <para>Can be passed with fractions of a second. For example, <literal>1.5</literal> will ask the
559                                 application to wait for 1.5 seconds.</para>
560                         </parameter>
561                 </syntax>
562                 <description>
563                         <para>This application waits for a specified number of <replaceable>seconds</replaceable>.</para>
564                 </description>
565         </application>
566         <application name="WaitExten" language="en_US">
567                 <synopsis>
568                         Waits for an extension to be entered.
569                 </synopsis>
570                 <syntax>
571                         <parameter name="seconds">
572                                 <para>Can be passed with fractions of a second. For example, <literal>1.5</literal> will ask the
573                                 application to wait for 1.5 seconds.</para>
574                         </parameter>
575                         <parameter name="options">
576                                 <optionlist>
577                                         <option name="m">
578                                                 <para>Provide music on hold to the caller while waiting for an extension.</para>
579                                                 <argument name="x">
580                                                         <para>Specify the class for music on hold.</para>
581                                                 </argument>
582                                         </option>
583                                 </optionlist>
584                         </parameter>
585                 </syntax>
586                 <description>
587                         <para>This application waits for the user to enter a new extension for a specified number
588                         of <replaceable>seconds</replaceable>.</para>
589                 </description>
590                 <see-also>
591                         <ref type="application">Playback</ref>
592                         <ref type="application">Background</ref>
593                 </see-also>
594         </application>
595         <function name="EXCEPTION" language="en_US">
596                 <synopsis>
597                         Retrieve the details of the current dialplan exception.
598                 </synopsis>
599                 <syntax>
600                         <parameter name="field" required="true">
601                                 <para>The following fields are available for retrieval:</para>
602                                 <enumlist>
603                                         <enum name="reason">
604                                                 <para>INVALID, ERROR, RESPONSETIMEOUT, ABSOLUTETIMEOUT, or custom
605                                                 value set by the RaiseException() application</para>
606                                         </enum>
607                                         <enum name="context">
608                                                 <para>The context executing when the exception occurred.</para>
609                                         </enum>
610                                         <enum name="exten">
611                                                 <para>The extension executing when the exception occurred.</para>
612                                         </enum>
613                                         <enum name="priority">
614                                                 <para>The numeric priority executing when the exception occurred.</para>
615                                         </enum>
616                                 </enumlist>
617                         </parameter>
618                 </syntax>
619                 <description>
620                         <para>Retrieve the details (specified <replaceable>field</replaceable>) of the current dialplan exception.</para>
621                 </description>
622         </function>
623  ***/
624
625 #ifdef LOW_MEMORY
626 #define EXT_DATA_SIZE 256
627 #else
628 #define EXT_DATA_SIZE 8192
629 #endif
630
631 #define SWITCH_DATA_LENGTH 256
632
633 #define VAR_BUF_SIZE 4096
634
635 #define VAR_NORMAL              1
636 #define VAR_SOFTTRAN    2
637 #define VAR_HARDTRAN    3
638
639 #define BACKGROUND_SKIP         (1 << 0)
640 #define BACKGROUND_NOANSWER     (1 << 1)
641 #define BACKGROUND_MATCHEXTEN   (1 << 2)
642 #define BACKGROUND_PLAYBACK     (1 << 3)
643
644 AST_APP_OPTIONS(background_opts, {
645         AST_APP_OPTION('s', BACKGROUND_SKIP),
646         AST_APP_OPTION('n', BACKGROUND_NOANSWER),
647         AST_APP_OPTION('m', BACKGROUND_MATCHEXTEN),
648         AST_APP_OPTION('p', BACKGROUND_PLAYBACK),
649 });
650
651 #define WAITEXTEN_MOH           (1 << 0)
652 #define WAITEXTEN_DIALTONE      (1 << 1)
653
654 AST_APP_OPTIONS(waitexten_opts, {
655         AST_APP_OPTION_ARG('m', WAITEXTEN_MOH, 0),
656         AST_APP_OPTION_ARG('d', WAITEXTEN_DIALTONE, 0),
657 });
658
659 struct ast_context;
660 struct ast_app;
661
662 static struct ast_taskprocessor *device_state_tps;
663
664 AST_THREADSTORAGE(switch_data);
665
666 /*!
667    \brief ast_exten: An extension
668         The dialplan is saved as a linked list with each context
669         having it's own linked list of extensions - one item per
670         priority.
671 */
672 struct ast_exten {
673         char *exten;                    /*!< Extension name */
674         int matchcid;                   /*!< Match caller id ? */
675         const char *cidmatch;           /*!< Caller id to match for this extension */
676         int priority;                   /*!< Priority */
677         const char *label;              /*!< Label */
678         struct ast_context *parent;     /*!< The context this extension belongs to  */
679         const char *app;                /*!< Application to execute */
680         struct ast_app *cached_app;     /*!< Cached location of application */
681         void *data;                     /*!< Data to use (arguments) */
682         void (*datad)(void *);          /*!< Data destructor */
683         struct ast_exten *peer;         /*!< Next higher priority with our extension */
684         struct ast_hashtab *peer_table;    /*!< Priorities list in hashtab form -- only on the head of the peer list */
685         struct ast_hashtab *peer_label_table; /*!< labeled priorities in the peers -- only on the head of the peer list */
686         const char *registrar;          /*!< Registrar */
687         struct ast_exten *next;         /*!< Extension with a greater ID */
688         char stuff[0];
689 };
690
691 /*! \brief ast_include: include= support in extensions.conf */
692 struct ast_include {
693         const char *name;
694         const char *rname;                      /*!< Context to include */
695         const char *registrar;                  /*!< Registrar */
696         int hastime;                            /*!< If time construct exists */
697         struct ast_timing timing;               /*!< time construct */
698         struct ast_include *next;               /*!< Link them together */
699         char stuff[0];
700 };
701
702 /*! \brief ast_sw: Switch statement in extensions.conf */
703 struct ast_sw {
704         char *name;
705         const char *registrar;                  /*!< Registrar */
706         char *data;                             /*!< Data load */
707         int eval;
708         AST_LIST_ENTRY(ast_sw) list;
709         char stuff[0];
710 };
711
712 /*! \brief ast_ignorepat: Ignore patterns in dial plan */
713 struct ast_ignorepat {
714         const char *registrar;
715         struct ast_ignorepat *next;
716         const char pattern[0];
717 };
718
719 /*! \brief match_char: forms a syntax tree for quick matching of extension patterns */
720 struct match_char
721 {
722         int is_pattern; /* the pattern started with '_' */
723         int deleted;    /* if this is set, then... don't return it */
724         char *x;       /* the pattern itself-- matches a single char */
725         int specificity; /* simply the strlen of x, or 10 for X, 9 for Z, and 8 for N; and '.' and '!' will add 11 ? */
726         struct match_char *alt_char;
727         struct match_char *next_char;
728         struct ast_exten *exten; /* attached to last char of a pattern for exten */
729 };
730
731 struct scoreboard  /* make sure all fields are 0 before calling new_find_extension */
732 {
733         int total_specificity;
734         int total_length;
735         char last_char;   /* set to ! or . if they are the end of the pattern */
736         int canmatch;     /* if the string to match was just too short */
737         struct match_char *node;
738         struct ast_exten *canmatch_exten;
739         struct ast_exten *exten;
740 };
741
742 /*! \brief ast_context: An extension context */
743 struct ast_context {
744         ast_rwlock_t lock;                      /*!< A lock to prevent multiple threads from clobbering the context */
745         struct ast_exten *root;                 /*!< The root of the list of extensions */
746         struct ast_hashtab *root_table;            /*!< For exact matches on the extensions in the pattern tree, and for traversals of the pattern_tree  */
747         struct match_char *pattern_tree;        /*!< A tree to speed up extension pattern matching */
748         struct ast_context *next;               /*!< Link them together */
749         struct ast_include *includes;           /*!< Include other contexts */
750         struct ast_ignorepat *ignorepats;       /*!< Patterns for which to continue playing dialtone */
751         char *registrar;                        /*!< Registrar -- make sure you malloc this, as the registrar may have to survive module unloads */
752         int refcount;                   /*!< each module that would have created this context should inc/dec this as appropriate */
753         AST_LIST_HEAD_NOLOCK(, ast_sw) alts;    /*!< Alternative switches */
754         ast_mutex_t macrolock;                  /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */
755         char name[0];                           /*!< Name of the context */
756 };
757
758 /*! \brief ast_app: A registered application */
759 struct ast_app {
760         int (*execute)(struct ast_channel *chan, void *data);
761         AST_DECLARE_STRING_FIELDS(
762                 AST_STRING_FIELD(synopsis);     /*!< Synopsis text for 'show applications' */
763                 AST_STRING_FIELD(description);  /*!< Description (help text) for 'show application &lt;name&gt;' */
764                 AST_STRING_FIELD(syntax);       /*!< Syntax text for 'core show applications' */
765                 AST_STRING_FIELD(arguments);    /*!< Arguments description */
766                 AST_STRING_FIELD(seealso);      /*!< See also */
767         );
768         enum ast_doc_src docsrc;/*!< Where the documentation come from. */
769         AST_RWLIST_ENTRY(ast_app) list;         /*!< Next app in list */
770         struct ast_module *module;              /*!< Module this app belongs to */
771         char name[0];                           /*!< Name of the application */
772 };
773
774 /*! \brief ast_state_cb: An extension state notify register item */
775 struct ast_state_cb {
776         int id;
777         void *data;
778         ast_state_cb_type callback;
779         AST_LIST_ENTRY(ast_state_cb) entry;
780 };
781
782 /*! \brief Structure for dial plan hints
783
784   \note Hints are pointers from an extension in the dialplan to one or
785   more devices (tech/name) 
786         - See \ref AstExtState
787 */
788 struct ast_hint {
789         struct ast_exten *exten;        /*!< Extension */
790         int laststate;                  /*!< Last known state */
791         AST_LIST_HEAD_NOLOCK(, ast_state_cb) callbacks; /*!< Callback list for this extension */
792         AST_RWLIST_ENTRY(ast_hint) list;/*!< Pointer to next hint in list */
793 };
794
795 static const struct cfextension_states {
796         int extension_state;
797         const char * const text;
798 } extension_states[] = {
799         { AST_EXTENSION_NOT_INUSE,                     "Idle" },
800         { AST_EXTENSION_INUSE,                         "InUse" },
801         { AST_EXTENSION_BUSY,                          "Busy" },
802         { AST_EXTENSION_UNAVAILABLE,                   "Unavailable" },
803         { AST_EXTENSION_RINGING,                       "Ringing" },
804         { AST_EXTENSION_INUSE | AST_EXTENSION_RINGING, "InUse&Ringing" },
805         { AST_EXTENSION_ONHOLD,                        "Hold" },
806         { AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD,  "InUse&Hold" }
807 };
808
809 struct statechange {
810         AST_LIST_ENTRY(statechange) entry;
811         char dev[0];
812 };
813
814 struct pbx_exception {
815         AST_DECLARE_STRING_FIELDS(
816                 AST_STRING_FIELD(context);      /*!< Context associated with this exception */
817                 AST_STRING_FIELD(exten);        /*!< Exten associated with this exception */
818                 AST_STRING_FIELD(reason);               /*!< The exception reason */
819         );
820
821         int priority;                           /*!< Priority associated with this exception */
822 };
823
824 #ifdef AST_XML_DOCS
825 /*! \brief Default documentation language. */
826 static const char default_documentation_language[] = "en_US";
827
828 /*! \brief Number of columns to print when showing the XML documentation with a 
829  *         'core show application/function *' CLI command. Used in text wrapping.*/
830 static const int xmldoc_text_columns = 74;
831
832 /*! \brief This is a value that we will use to let the wrapping mechanism move the cursor
833  *         backward and forward xmldoc_max_diff positions before cutting the middle of a
834  *         word, trying to find a space or a \n. */
835 static const int xmldoc_max_diff = 5;
836
837 /*! \brief XML documentation language. */
838 static char documentation_language[6];
839
840 /*! \brief XML documentation tree */
841 struct documentation_tree {
842         char *filename;                                 /*!< XML document filename. */
843         struct ast_xml_doc *doc;                        /*!< Open document pointer. */
844         AST_RWLIST_ENTRY(documentation_tree) entry;
845 };
846
847 /*!
848  * \brief Container of documentation trees
849  *
850  * \note A RWLIST is a sufficient container type to use here for now.
851  *       However, some changes will need to be made to implement ref counting
852  *       if reload support is added in the future.
853  */
854 static AST_RWLIST_HEAD_STATIC(xmldoc_tree, documentation_tree);
855 #endif
856
857 /*! \brief Maximum number of characters needed for a color escape sequence, plus a null char */
858 #define MAX_ESCAPE_CHARS   23
859
860 static int pbx_builtin_answer(struct ast_channel *, void *);
861 static int pbx_builtin_goto(struct ast_channel *, void *);
862 static int pbx_builtin_hangup(struct ast_channel *, void *);
863 static int pbx_builtin_background(struct ast_channel *, void *);
864 static int pbx_builtin_wait(struct ast_channel *, void *);
865 static int pbx_builtin_waitexten(struct ast_channel *, void *);
866 static int pbx_builtin_incomplete(struct ast_channel *, void *);
867 static int pbx_builtin_keepalive(struct ast_channel *, void *);
868 static int pbx_builtin_resetcdr(struct ast_channel *, void *);
869 static int pbx_builtin_setamaflags(struct ast_channel *, void *);
870 static int pbx_builtin_ringing(struct ast_channel *, void *);
871 static int pbx_builtin_proceeding(struct ast_channel *, void *);
872 static int pbx_builtin_progress(struct ast_channel *, void *);
873 static int pbx_builtin_congestion(struct ast_channel *, void *);
874 static int pbx_builtin_busy(struct ast_channel *, void *);
875 static int pbx_builtin_noop(struct ast_channel *, void *);
876 static int pbx_builtin_gotoif(struct ast_channel *, void *);
877 static int pbx_builtin_gotoiftime(struct ast_channel *, void *);
878 static int pbx_builtin_execiftime(struct ast_channel *, void *);
879 static int pbx_builtin_saynumber(struct ast_channel *, void *);
880 static int pbx_builtin_saydigits(struct ast_channel *, void *);
881 static int pbx_builtin_saycharacters(struct ast_channel *, void *);
882 static int pbx_builtin_sayphonetic(struct ast_channel *, void *);
883 static int matchcid(const char *cidpattern, const char *callerid);
884 int pbx_builtin_setvar(struct ast_channel *, void *);
885 void log_match_char_tree(struct match_char *node, char *prefix); /* for use anywhere */
886 int pbx_builtin_setvar_multiple(struct ast_channel *, void *);
887 static int pbx_builtin_importvar(struct ast_channel *, void *);
888 static void set_ext_pri(struct ast_channel *c, const char *exten, int pri); 
889 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);
890 static struct match_char *already_in_tree(struct match_char *current, char *pat);
891 static struct match_char *add_exten_to_pattern_tree(struct ast_context *con, struct ast_exten *e1, int findonly);
892 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);
893 static void create_match_char_tree(struct ast_context *con);
894 static struct ast_exten *get_canmatch_exten(struct match_char *node);
895 static void destroy_pattern_tree(struct match_char *pattern_tree);
896 int ast_hashtab_compare_contexts(const void *ah_a, const void *ah_b);
897 static int hashtab_compare_extens(const void *ha_a, const void *ah_b);
898 static int hashtab_compare_exten_numbers(const void *ah_a, const void *ah_b);
899 static int hashtab_compare_exten_labels(const void *ah_a, const void *ah_b);
900 unsigned int ast_hashtab_hash_contexts(const void *obj);
901 static unsigned int hashtab_hash_extens(const void *obj);
902 static unsigned int hashtab_hash_priority(const void *obj);
903 static unsigned int hashtab_hash_labels(const void *obj);
904 static void __ast_internal_context_destroy( struct ast_context *con);
905 #ifdef AST_XML_DOCS
906 static char *xmldoc_colorization(const char *bwinput);
907 #endif
908
909 /* a func for qsort to use to sort a char array */
910 static int compare_char(const void *a, const void *b)
911 {
912         const char *ac = a;
913         const char *bc = b;
914         if ((*ac) < (*bc))
915                 return -1;
916         else if ((*ac) == (*bc))
917                 return 0;
918         else
919                 return 1;
920 }
921
922 /* labels, contexts are case sensitive  priority numbers are ints */
923 int ast_hashtab_compare_contexts(const void *ah_a, const void *ah_b)
924 {
925         const struct ast_context *ac = ah_a;
926         const struct ast_context *bc = ah_b;
927         if (!ac || !bc) /* safety valve, but it might prevent a crash you'd rather have happen */
928                 return 1;
929         /* assume context names are registered in a string table! */
930         return strcmp(ac->name, bc->name);
931 }
932
933 static int hashtab_compare_extens(const void *ah_a, const void *ah_b)
934 {
935         const struct ast_exten *ac = ah_a;
936         const struct ast_exten *bc = ah_b;
937         int x = strcmp(ac->exten, bc->exten);
938         if (x) { /* if exten names are diff, then return */
939                 return x;
940         }
941         
942         /* but if they are the same, do the cidmatch values match? */
943         if (ac->matchcid && bc->matchcid) {
944                 return strcmp(ac->cidmatch,bc->cidmatch);
945         } else if (!ac->matchcid && !bc->matchcid) {
946                 return 0; /* if there's no matchcid on either side, then this is a match */
947         } else {
948                 return 1; /* if there's matchcid on one but not the other, they are different */
949         }
950 }
951
952 static int hashtab_compare_exten_numbers(const void *ah_a, const void *ah_b)
953 {
954         const struct ast_exten *ac = ah_a;
955         const struct ast_exten *bc = ah_b;
956         return ac->priority != bc->priority;
957 }
958
959 static int hashtab_compare_exten_labels(const void *ah_a, const void *ah_b)
960 {
961         const struct ast_exten *ac = ah_a;
962         const struct ast_exten *bc = ah_b;
963         return strcmp(ac->label, bc->label);
964 }
965
966 unsigned int ast_hashtab_hash_contexts(const void *obj)
967 {
968         const struct ast_context *ac = obj;
969         return ast_hashtab_hash_string(ac->name);
970 }
971
972 static unsigned int hashtab_hash_extens(const void *obj)
973 {
974         const struct ast_exten *ac = obj;
975         unsigned int x = ast_hashtab_hash_string(ac->exten);
976         unsigned int y = 0;
977         if (ac->matchcid)
978                 y = ast_hashtab_hash_string(ac->cidmatch);
979         return x+y;
980 }
981
982 static unsigned int hashtab_hash_priority(const void *obj)
983 {
984         const struct ast_exten *ac = obj;
985         return ast_hashtab_hash_int(ac->priority);
986 }
987
988 static unsigned int hashtab_hash_labels(const void *obj)
989 {
990         const struct ast_exten *ac = obj;
991         return ast_hashtab_hash_string(ac->label);
992 }
993
994
995 AST_RWLOCK_DEFINE_STATIC(globalslock);
996 static struct varshead globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
997
998 static int autofallthrough = 1;
999 static int extenpatternmatchnew = 0;
1000 static char *overrideswitch = NULL;
1001
1002 /*! \brief Subscription for device state change events */
1003 static struct ast_event_sub *device_state_sub;
1004
1005 AST_MUTEX_DEFINE_STATIC(maxcalllock);
1006 static int countcalls;
1007 static int totalcalls;
1008
1009 static AST_RWLIST_HEAD_STATIC(acf_root, ast_custom_function);
1010
1011 /*! \brief Declaration of builtin applications */
1012 static struct pbx_builtin {
1013         char name[AST_MAX_APP];
1014         int (*execute)(struct ast_channel *chan, void *data);
1015 } builtins[] =
1016 {
1017         /* These applications are built into the PBX core and do not
1018            need separate modules */
1019
1020         { "Answer",         pbx_builtin_answer },
1021         { "BackGround",     pbx_builtin_background },
1022         { "Busy",           pbx_builtin_busy },
1023         { "Congestion",     pbx_builtin_congestion },
1024         { "ExecIfTime",     pbx_builtin_execiftime },
1025         { "Goto",           pbx_builtin_goto },
1026         { "GotoIf",         pbx_builtin_gotoif },
1027         { "GotoIfTime",     pbx_builtin_gotoiftime },
1028         { "ImportVar",      pbx_builtin_importvar },
1029         { "Hangup",         pbx_builtin_hangup },
1030         { "Incomplete",     pbx_builtin_incomplete },
1031         { "KeepAlive",      pbx_builtin_keepalive },
1032         { "NoOp",           pbx_builtin_noop },
1033         { "Proceeding",     pbx_builtin_proceeding },
1034         { "Progress",       pbx_builtin_progress },
1035         { "RaiseException", pbx_builtin_raise_exception },
1036         { "ResetCDR",       pbx_builtin_resetcdr },
1037         { "Ringing",        pbx_builtin_ringing },
1038         { "SayAlpha",       pbx_builtin_saycharacters },
1039         { "SayDigits",      pbx_builtin_saydigits },
1040         { "SayNumber",      pbx_builtin_saynumber },
1041         { "SayPhonetic",    pbx_builtin_sayphonetic },
1042         { "Set",            pbx_builtin_setvar },
1043         { "MSet",           pbx_builtin_setvar_multiple },
1044         { "SetAMAFlags",    pbx_builtin_setamaflags },
1045         { "Wait",           pbx_builtin_wait },
1046         { "WaitExten",      pbx_builtin_waitexten }
1047 };
1048
1049 static struct ast_context *contexts;
1050 static struct ast_hashtab *contexts_table = NULL;
1051
1052 AST_RWLOCK_DEFINE_STATIC(conlock);              /*!< Lock for the ast_context list */
1053
1054 static AST_RWLIST_HEAD_STATIC(apps, ast_app);
1055
1056 static AST_RWLIST_HEAD_STATIC(switches, ast_switch);
1057
1058 static int stateid = 1;
1059 /* WARNING:
1060    When holding this list's lock, do _not_ do anything that will cause conlock
1061    to be taken, unless you _already_ hold it. The ast_merge_contexts_and_delete
1062    function will take the locks in conlock/hints order, so any other
1063    paths that require both locks must also take them in that order.
1064 */
1065 static AST_RWLIST_HEAD_STATIC(hints, ast_hint);
1066
1067 static AST_LIST_HEAD_NOLOCK_STATIC(statecbs, ast_state_cb);
1068
1069 #ifdef CONTEXT_DEBUG
1070
1071 /* these routines are provided for doing run-time checks
1072    on the extension structures, in case you are having
1073    problems, this routine might help you localize where
1074    the problem is occurring. It's kinda like a debug memory
1075    allocator's arena checker... It'll eat up your cpu cycles!
1076    but you'll see, if you call it in the right places,
1077    right where your problems began...
1078 */
1079
1080 /* you can break on the check_contexts_trouble()
1081 routine in your debugger to stop at the moment
1082 there's a problem */
1083 void check_contexts_trouble(void);
1084
1085 void check_contexts_trouble(void)
1086 {
1087         int x = 1;
1088         x = 2;
1089 }
1090
1091 static struct ast_context *find_context_locked(const char *context);
1092 int check_contexts(char *, int);
1093
1094 int check_contexts(char *file, int line )
1095 {
1096         struct ast_hashtab_iter *t1;
1097         struct ast_context *c1, *c2;
1098         int found = 0;
1099         struct ast_exten *e1, *e2, *e3;
1100         struct ast_exten ex;
1101         
1102         /* try to find inconsistencies */
1103         /* is every context in the context table in the context list and vice-versa ? */
1104         
1105         if (!contexts_table) {
1106                 ast_log(LOG_NOTICE,"Called from: %s:%d: No contexts_table!\n", file, line);
1107                 usleep(500000);
1108         }
1109
1110         t1 = ast_hashtab_start_traversal(contexts_table);
1111         while( (c1 = ast_hashtab_next(t1))) {
1112                 for(c2=contexts;c2;c2=c2->next) {
1113                         if (!strcmp(c1->name, c2->name)) {
1114                                 found = 1;
1115                                 break;
1116                         }
1117                 }
1118                 if (!found) {
1119                         ast_log(LOG_NOTICE,"Called from: %s:%d: Could not find the %s context in the linked list\n", file, line, c1->name);
1120                         check_contexts_trouble();
1121                 }
1122         }
1123         ast_hashtab_end_traversal(t1);
1124         for(c2=contexts;c2;c2=c2->next) {
1125                 c1 = find_context_locked(c2->name);
1126                 if (!c1) {
1127                         ast_log(LOG_NOTICE,"Called from: %s:%d: Could not find the %s context in the hashtab\n", file, line, c2->name);
1128                         check_contexts_trouble();
1129                 } else
1130                         ast_unlock_contexts();
1131         }
1132
1133         /* loop thru all contexts, and verify the exten structure compares to the 
1134            hashtab structure */
1135         for(c2=contexts;c2;c2=c2->next) {
1136                 c1 = find_context_locked(c2->name);
1137                 if (c1)
1138                 {
1139
1140                         ast_unlock_contexts();
1141
1142                         /* is every entry in the root list also in the root_table? */
1143                         for(e1 = c1->root; e1; e1=e1->next)
1144                         {
1145                                 char dummy_name[1024];
1146                                 ex.exten = dummy_name;
1147                                 ex.matchcid = e1->matchcid;
1148                                 ex.cidmatch = e1->cidmatch;
1149                                 ast_copy_string(dummy_name, e1->exten, sizeof(dummy_name));
1150                                 e2 = ast_hashtab_lookup(c1->root_table, &ex);
1151                                 if (!e2) {
1152                                         if (e1->matchcid) {
1153                                                 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 );
1154                                         } else {
1155                                                 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 );
1156                                         }
1157                                         check_contexts_trouble();
1158                                 }
1159                         }
1160                         
1161                         /* is every entry in the root_table also in the root list? */ 
1162                         if (!c2->root_table) {
1163                                 if (c2->root) {
1164                                         ast_log(LOG_NOTICE,"Called from: %s:%d: No c2->root_table for context %s!\n", file, line, c2->name);
1165                                         usleep(500000);
1166                                 }
1167                         } else {
1168                                 t1 = ast_hashtab_start_traversal(c2->root_table);
1169                                 while( (e2 = ast_hashtab_next(t1)) ) {
1170                                         for(e1=c2->root;e1;e1=e1->next) {
1171                                                 if (!strcmp(e1->exten, e2->exten)) {
1172                                                         found = 1;
1173                                                         break;
1174                                                 }
1175                                         }
1176                                         if (!found) {
1177                                                 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);
1178                                                 check_contexts_trouble();
1179                                         }
1180                                         
1181                                 }
1182                                 ast_hashtab_end_traversal(t1);
1183                         }
1184                 }
1185                 /* is every priority reflected in the peer_table at the head of the list? */
1186                 
1187                 /* is every entry in the root list also in the root_table? */
1188                 /* are the per-extension peer_tables in the right place? */
1189
1190                 for(e1 = c2->root; e1; e1 = e1->next) {
1191                         
1192                         for(e2=e1;e2;e2=e2->peer) {
1193                                 ex.priority = e2->priority;
1194                                 if (e2 != e1 && e2->peer_table) {
1195                                         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 );
1196                                         check_contexts_trouble();
1197                                 }
1198                                 
1199                                 if (e2 != e1 && e2->peer_label_table) {
1200                                         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 );
1201                                         check_contexts_trouble();
1202                                 }
1203                                 
1204                                 if (e2 == e1 && !e2->peer_table){
1205                                         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 );
1206                                         check_contexts_trouble();
1207                                 }
1208                                 
1209                                 if (e2 == e1 && !e2->peer_label_table) {
1210                                         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 );
1211                                         check_contexts_trouble();
1212                                 }
1213                                 
1214
1215                                 e3 = ast_hashtab_lookup(e1->peer_table, &ex);
1216                                 if (!e3) {
1217                                         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 );
1218                                         check_contexts_trouble();
1219                                 }
1220                         }
1221                         
1222                         if (!e1->peer_table){
1223                                 ast_log(LOG_NOTICE,"Called from: %s:%d: No e1->peer_table!\n", file, line);
1224                                 usleep(500000);
1225                         }
1226                         
1227                         /* is every entry in the peer_table also in the peer list? */ 
1228                         t1 = ast_hashtab_start_traversal(e1->peer_table);
1229                         while( (e2 = ast_hashtab_next(t1)) ) {
1230                                 for(e3=e1;e3;e3=e3->peer) {
1231                                         if (e3->priority == e2->priority) {
1232                                                 found = 1;
1233                                                 break;
1234                                         }
1235                                 }
1236                                 if (!found) {
1237                                         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 );
1238                                         check_contexts_trouble();
1239                                 }
1240                         }
1241                         ast_hashtab_end_traversal(t1);
1242                 }
1243         }
1244         return 0;
1245 }
1246 #endif
1247
1248 /*
1249    \note This function is special. It saves the stack so that no matter
1250    how many times it is called, it returns to the same place */
1251 int pbx_exec(struct ast_channel *c,             /*!< Channel */
1252              struct ast_app *app,               /*!< Application */
1253              void *data)                        /*!< Data for execution */
1254 {
1255         int res;
1256         struct ast_module_user *u = NULL;
1257         const char *saved_c_appl;
1258         const char *saved_c_data;
1259
1260         if (c->cdr && !ast_check_hangup(c))
1261                 ast_cdr_setapp(c->cdr, app->name, data);
1262
1263         /* save channel values */
1264         saved_c_appl= c->appl;
1265         saved_c_data= c->data;
1266
1267         c->appl = app->name;
1268         c->data = data;
1269         if (app->module)
1270                 u = __ast_module_user_add(app->module, c);
1271         res = app->execute(c, S_OR(data, ""));
1272         if (app->module && u)
1273                 __ast_module_user_remove(app->module, u);
1274         /* restore channel values */
1275         c->appl = saved_c_appl;
1276         c->data = saved_c_data;
1277         return res;
1278 }
1279
1280
1281 /*! Go no deeper than this through includes (not counting loops) */
1282 #define AST_PBX_MAX_STACK       128
1283
1284 /*! \brief Find application handle in linked list
1285  */
1286 struct ast_app *pbx_findapp(const char *app)
1287 {
1288         struct ast_app *tmp;
1289
1290         AST_RWLIST_RDLOCK(&apps);
1291         AST_RWLIST_TRAVERSE(&apps, tmp, list) {
1292                 if (!strcasecmp(tmp->name, app))
1293                         break;
1294         }
1295         AST_RWLIST_UNLOCK(&apps);
1296
1297         return tmp;
1298 }
1299
1300 static struct ast_switch *pbx_findswitch(const char *sw)
1301 {
1302         struct ast_switch *asw;
1303
1304         AST_RWLIST_RDLOCK(&switches);
1305         AST_RWLIST_TRAVERSE(&switches, asw, list) {
1306                 if (!strcasecmp(asw->name, sw))
1307                         break;
1308         }
1309         AST_RWLIST_UNLOCK(&switches);
1310
1311         return asw;
1312 }
1313
1314 static inline int include_valid(struct ast_include *i)
1315 {
1316         if (!i->hastime)
1317                 return 1;
1318
1319         return ast_check_timing(&(i->timing));
1320 }
1321
1322 static void pbx_destroy(struct ast_pbx *p)
1323 {
1324         ast_free(p);
1325 }
1326
1327 /* form a tree that fully describes all the patterns in a context's extensions 
1328  * in this tree, a "node" represents an individual character or character set
1329  * meant to match the corresponding character in a dial string. The tree 
1330  * consists of a series of match_char structs linked in a chain
1331  * via the alt_char pointers. More than one pattern can share the same parts of the 
1332  * tree as other extensions with the same pattern to that point. 
1333  * My first attempt to duplicate the finding of the 'best' pattern was flawed in that
1334  * I misunderstood the general algorithm. I thought that the 'best' pattern
1335  * was the one with lowest total score. This was not true. Thus, if you have
1336  * patterns "1XXXXX" and "X11111", you would be tempted to say that "X11111" is
1337  * the "best" match because it has fewer X's, and is therefore more specific, 
1338  * but this is not how the old algorithm works. It sorts matching patterns
1339  * in a similar collating sequence as sorting alphabetic strings, from left to 
1340  * right. Thus, "1XXXXX" comes before "X11111", and would be the "better" match,
1341  * because "1" is more specific than "X".
1342  * So, to accomodate this philosophy, I sort the tree branches along the alt_char
1343  * line so they are lowest to highest in specificity numbers. This way, as soon
1344  * as we encounter our first complete match, we automatically have the "best" 
1345  * match and can stop the traversal immediately. Same for CANMATCH/MATCHMORE.
1346  * If anyone would like to resurrect the "wrong" pattern trie searching algorithm,
1347  * they are welcome to revert pbx to before 1 Apr 2008.
1348  * As an example, consider these 4 extensions:
1349  * (a) NXXNXXXXXX
1350  * (b) 307754XXXX 
1351  * (c) fax
1352  * (d) NXXXXXXXXX
1353  *
1354  * In the above, between (a) and (d), (a) is a more specific pattern than (d), and would win over
1355  * most numbers. For all numbers beginning with 307754, (b) should always win.
1356  *
1357  * These pattern should form a (sorted) tree that looks like this:
1358  *   { "3" }  --next-->  { "0" }  --next--> { "7" } --next--> { "7" } --next--> { "5" } ... blah ... --> { "X" exten_match: (b) }
1359  *      |
1360  *      |alt
1361  *      |
1362  *   { "f" }  --next-->  { "a" }  --next--> { "x"  exten_match: (c) }
1363  *   { "N" }  --next-->  { "X" }  --next--> { "X" } --next--> { "N" } --next--> { "X" } ... blah ... --> { "X" exten_match: (a) }
1364  *      |                                                        |
1365  *      |                                                        |alt
1366  *      |alt                                                     |
1367  *      |                                                     { "X" } --next--> { "X" } ... blah ... --> { "X" exten_match: (d) }
1368  *      |
1369  *     NULL
1370  *
1371  *   In the above, I could easily turn "N" into "23456789", but I think that a quick "if( *z >= '2' && *z <= '9' )" might take
1372  *   fewer CPU cycles than a call to strchr("23456789",*z), where *z is the char to match...
1373  *
1374  *   traversal is pretty simple: one routine merely traverses the alt list, and for each matching char in the pattern,  it calls itself
1375  *   on the corresponding next pointer, incrementing also the pointer of the string to be matched, and passing the total specificity and length.
1376  *   We pass a pointer to a scoreboard down through, also.
1377  *   The scoreboard isn't as necessary to the revised algorithm, but I kept it as a handy way to return the matched extension.
1378  *   The first complete match ends the traversal, which should make this version of the pattern matcher faster
1379  *   the previous. The same goes for "CANMATCH" or "MATCHMORE"; the first such match ends the traversal. In both
1380  *   these cases, the reason we can stop immediately, is because the first pattern match found will be the "best"
1381  *   according to the sort criteria.
1382  *   Hope the limit on stack depth won't be a problem... this routine should 
1383  *   be pretty lean as far a stack usage goes. Any non-match terminates the recursion down a branch.
1384  *
1385  *   In the above example, with the number "3077549999" as the pattern, the traversor could match extensions a, b and d.  All are
1386  *   of length 10; they have total specificities of  24580, 10246, and 25090, respectively, not that this matters
1387  *   at all. (b) wins purely because the first character "3" is much more specific (lower specificity) than "N". I have
1388  *   left the specificity totals in the code as an artifact; at some point, I will strip it out.
1389  *
1390  *   Just how much time this algorithm might save over a plain linear traversal over all possible patterns is unknown,
1391  *   because it's a function of how many extensions are stored in a context. With thousands of extensions, the speedup
1392  *   can be very noticeable. The new matching algorithm can run several hundreds of times faster, if not a thousand or
1393  *   more times faster in extreme cases.
1394  *
1395  *   MatchCID patterns are also supported, and stored in the tree just as the extension pattern is. Thus, you
1396  *   can have patterns in your CID field as well.
1397  *
1398  * */
1399
1400
1401 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)
1402 {
1403         /* if this extension is marked as deleted, then skip this -- if it never shows
1404            on the scoreboard, it will never be found, nor will halt the traversal. */
1405         if (deleted)
1406                 return;
1407         board->total_specificity = spec;
1408         board->total_length = length;
1409         board->exten = exten;
1410         board->last_char = last;
1411         board->node = node;
1412 #ifdef NEED_DEBUG_HERE
1413         ast_log(LOG_NOTICE,"Scoreboarding (LONGER) %s, len=%d, score=%d\n", exten->exten, length, spec);
1414 #endif
1415 }
1416
1417 void log_match_char_tree(struct match_char *node, char *prefix)
1418 {
1419         char extenstr[40];
1420         struct ast_str *my_prefix = ast_str_alloca(1024); 
1421
1422         extenstr[0] = '\0';
1423
1424         if (node && node->exten && node->exten)
1425                 snprintf(extenstr, sizeof(extenstr), "(%p)", node->exten);
1426         
1427         if (strlen(node->x) > 1) {
1428                 ast_debug(1, "%s[%s]:%c:%c:%d:%s%s%s\n", prefix, node->x, node->is_pattern ? 'Y':'N', 
1429                         node->deleted? 'D':'-', node->specificity, node->exten? "EXTEN:":"", 
1430                         node->exten ? node->exten->exten : "", extenstr);
1431         } else {
1432                 ast_debug(1, "%s%s:%c:%c:%d:%s%s%s\n", prefix, node->x, node->is_pattern ? 'Y':'N', 
1433                         node->deleted? 'D':'-', node->specificity, node->exten? "EXTEN:":"", 
1434                         node->exten ? node->exten->exten : "", extenstr);
1435         }
1436
1437         ast_str_set(&my_prefix, 0, "%s+       ", prefix);
1438
1439         if (node->next_char)
1440                 log_match_char_tree(node->next_char, my_prefix->str);
1441
1442         if (node->alt_char)
1443                 log_match_char_tree(node->alt_char, prefix);
1444 }
1445
1446 static void cli_match_char_tree(struct match_char *node, char *prefix, int fd)
1447 {
1448         char extenstr[40];
1449         struct ast_str *my_prefix = ast_str_alloca(1024);
1450         
1451         extenstr[0] = '\0';
1452
1453         if (node && node->exten && node->exten)
1454                 snprintf(extenstr, sizeof(extenstr), "(%p)", node->exten);
1455         
1456         if (strlen(node->x) > 1) {
1457                 ast_cli(fd, "%s[%s]:%c:%c:%d:%s%s%s\n", prefix, node->x, node->is_pattern ? 'Y' : 'N', 
1458                         node->deleted ? 'D' : '-', node->specificity, node->exten? "EXTEN:" : "", 
1459                         node->exten ? node->exten->exten : "", extenstr);
1460         } else {
1461                 ast_cli(fd, "%s%s:%c:%c:%d:%s%s%s\n", prefix, node->x, node->is_pattern ? 'Y' : 'N', 
1462                         node->deleted ? 'D' : '-', node->specificity, node->exten? "EXTEN:" : "", 
1463                         node->exten ? node->exten->exten : "", extenstr);
1464         }
1465
1466         ast_str_set(&my_prefix, 0, "%s+       ", prefix);
1467
1468         if (node->next_char)
1469                 cli_match_char_tree(node->next_char, my_prefix->str, fd);
1470
1471         if (node->alt_char)
1472                 cli_match_char_tree(node->alt_char, prefix, fd);
1473 }
1474
1475 static struct ast_exten *get_canmatch_exten(struct match_char *node)
1476 {
1477         /* find the exten at the end of the rope */
1478         struct match_char *node2 = node;
1479
1480         for (node2 = node; node2; node2 = node2->next_char) {
1481                 if (node2->exten) {
1482 #ifdef NEED_DEBUG_HERE
1483                         ast_log(LOG_NOTICE,"CanMatch_exten returns exten %s(%p)\n", node2->exten->exten, node2->exten);
1484 #endif
1485                         return node2->exten;
1486                 }
1487         }
1488 #ifdef NEED_DEBUG_HERE
1489         ast_log(LOG_NOTICE,"CanMatch_exten returns NULL, match_char=%s\n", node->x);
1490 #endif
1491         return 0;
1492 }
1493
1494 static struct ast_exten *trie_find_next_match(struct match_char *node)
1495 {
1496         struct match_char *m3;
1497         struct match_char *m4;
1498         struct ast_exten *e3;
1499         
1500         if (node && node->x[0] == '.' && !node->x[1]) /* dot and ! will ALWAYS be next match in a matchmore */
1501                 return node->exten;
1502         
1503         if (node && node->x[0] == '!' && !node->x[1])
1504                 return node->exten;
1505         
1506         if (!node || !node->next_char)
1507                 return NULL;
1508         
1509         m3 = node->next_char;
1510
1511         if (m3->exten)
1512                 return m3->exten;
1513         for(m4=m3->alt_char; m4; m4 = m4->alt_char) {
1514                 if (m4->exten)
1515                         return m4->exten;
1516         }
1517         for(m4=m3; m4; m4 = m4->alt_char) {
1518                 e3 = trie_find_next_match(m3);
1519                 if (e3)
1520                         return e3;
1521         }
1522         return NULL;
1523 }
1524
1525 #ifdef DEBUG_THIS
1526 static char *action2str(enum ext_match_t action)
1527 {
1528         switch(action)
1529         {
1530         case E_MATCH:
1531                 return "MATCH";
1532         case E_CANMATCH:
1533                 return "CANMATCH";
1534         case E_MATCHMORE:
1535                 return "MATCHMORE";
1536         case E_FINDLABEL:
1537                 return "FINDLABEL";
1538         case E_SPAWN:
1539                 return "SPAWN";
1540         default:
1541                 return "?ACTION?";
1542         }
1543 }
1544
1545 #endif
1546
1547 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)
1548 {
1549         struct match_char *p; /* note minimal stack storage requirements */
1550         struct ast_exten pattern = { .label = label };
1551 #ifdef DEBUG_THIS
1552         if (tree)
1553                 ast_log(LOG_NOTICE,"new_find_extension called with %s on (sub)tree %s action=%s\n", str, tree->x, action2str(action));
1554         else
1555                 ast_log(LOG_NOTICE,"new_find_extension called with %s on (sub)tree NULL action=%s\n", str, action2str(action));
1556 #endif
1557         for (p=tree; p; p=p->alt_char) {
1558                 if (p->x[0] == 'N') {
1559                         if (p->x[1] == 0 && *str >= '2' && *str <= '9' ) {
1560 #define NEW_MATCHER_CHK_MATCH          \
1561                                 if (p->exten && !(*(str+1))) { /* if a shorter pattern matches along the way, might as well report it */             \
1562                                         if (action == E_MATCH || action == E_SPAWN || action == E_FINDLABEL) { /* if in CANMATCH/MATCHMORE, don't let matches get in the way */   \
1563                                                 update_scoreboard(score, length+1, spec+p->specificity, p->exten,0,callerid, p->deleted, p);                 \
1564                                                 if (!p->deleted) {                                                                                           \
1565                                                         if (action == E_FINDLABEL) {                                                                             \
1566                                                                 if (ast_hashtab_lookup(score->exten->peer_label_table, &pattern)) {                                  \
1567                                                                         ast_debug(4, "Found label in preferred extension\n");                                            \
1568                                                                         return;                                                                                          \
1569                                                                 }                                                                                                    \
1570                                                         } else {                                                                                                 \
1571                                                                 ast_debug(4,"returning an exact match-- first found-- %s\n", p->exten->exten);                       \
1572                                                                 return; /* the first match, by definition, will be the best, because of the sorted tree */           \
1573                                                         }                                                                                                        \
1574                                                 }                                                                                                            \
1575                                         }                                                                                                                \
1576                                 }
1577                                 
1578 #define NEW_MATCHER_RECURSE                \
1579                                 if (p->next_char && ( *(str+1) || (p->next_char->x[0] == '/' && p->next_char->x[1] == 0)                 \
1580                                                || p->next_char->x[0] == '!')) {                                          \
1581                                         if (*(str+1) || p->next_char->x[0] == '!') {                                                         \
1582                                                 new_find_extension(str+1, score, p->next_char, length+1, spec+p->specificity, callerid, label, action); \
1583                                                 if (score->exten)  {                                                                             \
1584                                                 ast_debug(4,"returning an exact match-- %s\n", score->exten->exten);                         \
1585                                                         return; /* the first match is all we need */                                                 \
1586                                                 }                                                                                                                                                \
1587                                         } else {                                                                                             \
1588                                                 new_find_extension("/", score, p->next_char, length+1, spec+p->specificity, callerid, label, action);    \
1589                                                 if (score->exten || ((action == E_CANMATCH || action == E_MATCHMORE) && score->canmatch)) {      \
1590                                                 ast_debug(4,"returning a (can/more) match--- %s\n", score->exten ? score->exten->exten :     \
1591                                        "NULL");                                                                        \
1592                                                         return; /* the first match is all we need */                                                 \
1593                                                 }                                                                                                                                                \
1594                                         }                                                                                                    \
1595                                 } else if (p->next_char && !*(str+1)) {                                                                  \
1596                                         score->canmatch = 1;                                                                                 \
1597                                         score->canmatch_exten = get_canmatch_exten(p);                                                       \
1598                                         if (action == E_CANMATCH || action == E_MATCHMORE) {                                                 \
1599                                         ast_debug(4,"returning a canmatch/matchmore--- str=%s\n", str);                                  \
1600                                                 return;                                                                                          \
1601                                         }                                                                                                                                                    \
1602                                 }
1603                                 
1604                                 NEW_MATCHER_CHK_MATCH;
1605                                 NEW_MATCHER_RECURSE;
1606                         }
1607                 } else if (p->x[0] == 'Z') {
1608                         if (p->x[1] == 0 && *str >= '1' && *str <= '9' ) {
1609                                 NEW_MATCHER_CHK_MATCH;
1610                                 NEW_MATCHER_RECURSE;
1611                         }
1612                 } else if (p->x[0] == 'X') { 
1613                         if (p->x[1] == 0 && *str >= '0' && *str <= '9' ) {
1614                                 NEW_MATCHER_CHK_MATCH;
1615                                 NEW_MATCHER_RECURSE;
1616                         }
1617                 } else if (p->x[0] == '.' && p->x[1] == 0) {
1618                         /* how many chars will the . match against? */
1619                         int i = 0;
1620                         const char *str2 = str;
1621                         while (*str2 && *str2 != '/') {
1622                                 str2++;
1623                                 i++;
1624                         }
1625                         if (p->exten && *str2 != '/') {
1626                                 update_scoreboard(score, length+i, spec+(i*p->specificity), p->exten, '.', callerid, p->deleted, p);
1627                                 if (score->exten) {
1628                                         ast_debug(4,"return because scoreboard has a match with '/'--- %s\n", score->exten->exten);
1629                                         return; /* the first match is all we need */
1630                                 }
1631                         }
1632                         if (p->next_char && p->next_char->x[0] == '/' && p->next_char->x[1] == 0) {
1633                                 new_find_extension("/", score, p->next_char, length+i, spec+(p->specificity*i), callerid, label, action);
1634                                 if (score->exten || ((action == E_CANMATCH || action == E_MATCHMORE) && score->canmatch)) {
1635                                         ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set--- %s\n", score->exten ? score->exten->exten : "NULL");
1636                                         return; /* the first match is all we need */
1637                                 }
1638                         }
1639                 } else if (p->x[0] == '!' && p->x[1] == 0) {
1640                         /* how many chars will the . match against? */
1641                         int i = 1;
1642                         const char *str2 = str;
1643                         while (*str2 && *str2 != '/') {
1644                                 str2++;
1645                                 i++;
1646                         }
1647                         if (p->exten && *str2 != '/') {
1648                                 update_scoreboard(score, length+1, spec+(p->specificity*i), p->exten, '!', callerid, p->deleted, p);
1649                                 if (score->exten) {
1650                                         ast_debug(4,"return because scoreboard has a '!' match--- %s\n", score->exten->exten);
1651                                         return; /* the first match is all we need */
1652                                 }
1653                         }
1654                         if (p->next_char && p->next_char->x[0] == '/' && p->next_char->x[1] == 0) {
1655                                 new_find_extension("/", score, p->next_char, length+i, spec+(p->specificity*i), callerid, label, action);
1656                                 if (score->exten || ((action == E_CANMATCH || action == E_MATCHMORE) && score->canmatch)) {
1657                                         ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set with '/' and '!'--- %s\n", score->exten ? score->exten->exten : "NULL");
1658                                         return; /* the first match is all we need */
1659                                 }
1660                         }
1661                 } else if (p->x[0] == '/' && p->x[1] == 0) {
1662                         /* the pattern in the tree includes the cid match! */
1663                         if (p->next_char && callerid && *callerid) {
1664                                 new_find_extension(callerid, score, p->next_char, length+1, spec, callerid, label, action);
1665                                 if (score->exten || ((action == E_CANMATCH || action == E_MATCHMORE) && score->canmatch)) {
1666                                         ast_debug(4,"return because scoreboard has exact match OR CANMATCH/MATCHMORE & canmatch set with '/'--- %s\n", score->exten ? score->exten->exten : "NULL");
1667                                         return; /* the first match is all we need */
1668                                 }
1669                         }
1670                 } else if (strchr(p->x, *str)) {
1671                         ast_debug(4, "Nothing strange about this match\n");
1672                         NEW_MATCHER_CHK_MATCH;
1673                         NEW_MATCHER_RECURSE;
1674                 }
1675         }
1676         ast_debug(4,"return at end of func\n");
1677 }
1678
1679 /* the algorithm for forming the extension pattern tree is also a bit simple; you 
1680  * traverse all the extensions in a context, and for each char of the extension,
1681  * you see if it exists in the tree; if it doesn't, you add it at the appropriate
1682  * spot. What more can I say? At the end of each exten, you cap it off by adding the
1683  * address of the extension involved. Duplicate patterns will be complained about.
1684  *
1685  * Ideally, this would be done for each context after it is created and fully 
1686  * filled. It could be done as a finishing step after extensions.conf or .ael is
1687  * loaded, or it could be done when the first search is encountered. It should only
1688  * have to be done once, until the next unload or reload.
1689  *
1690  * I guess forming this pattern tree would be analogous to compiling a regex. Except
1691  * that a regex only handles 1 pattern, really. This trie holds any number
1692  * of patterns. Well, really, it **could** be considered a single pattern,
1693  * where the "|" (or) operator is allowed, I guess, in a way, sort of...
1694  */
1695
1696 static struct match_char *already_in_tree(struct match_char *current, char *pat)
1697 {
1698         struct match_char *t;
1699
1700         if (!current)
1701                 return 0;
1702
1703         for (t = current; t; t = t->alt_char) {
1704                 if (!strcmp(pat, t->x)) /* uh, we may want to sort exploded [] contents to make matching easy */
1705                         return t;
1706         }
1707
1708         return 0;
1709 }
1710
1711 /* The first arg is the location of the tree ptr, or the 
1712    address of the next_char ptr in the node, so we can mess
1713    with it, if we need to insert at the beginning of the list */
1714
1715 static void insert_in_next_chars_alt_char_list(struct match_char **parent_ptr, struct match_char *node)
1716 {
1717         struct match_char *curr, *lcurr;
1718         
1719         /* insert node into the tree at "current", so the alt_char list from current is
1720            sorted in increasing value as you go to the leaves */
1721         if (!(*parent_ptr)) {
1722                 *parent_ptr = node;
1723         } else {
1724                 if ((*parent_ptr)->specificity > node->specificity){
1725                         /* insert at head */
1726                         node->alt_char = (*parent_ptr);
1727                         *parent_ptr = node;
1728                 } else {
1729                         lcurr = *parent_ptr;
1730                         for (curr=(*parent_ptr)->alt_char; curr; curr = curr->alt_char) {
1731                                 if (curr->specificity > node->specificity) {
1732                                         node->alt_char = curr;
1733                                         lcurr->alt_char = node;
1734                                         break;
1735                                 }
1736                                 lcurr = curr;
1737                         }
1738                         if (!curr) {
1739                                 lcurr->alt_char = node;
1740                         }
1741                 }
1742         }
1743 }
1744
1745
1746
1747 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)
1748 {
1749         struct match_char *m;
1750         
1751         if (!(m = ast_calloc(1, sizeof(*m))))
1752                 return NULL;
1753
1754         if (!(m->x = ast_strdup(pattern))) {
1755                 ast_free(m);
1756                 return NULL;
1757         }
1758
1759         /* the specificity scores are the same as used in the old
1760            pattern matcher. */
1761         m->is_pattern = is_pattern;
1762         if (specificity == 1 && is_pattern && pattern[0] == 'N')
1763                 m->specificity = 0x0802;
1764         else if (specificity == 1 && is_pattern && pattern[0] == 'Z')
1765                 m->specificity = 0x0901;
1766         else if (specificity == 1 && is_pattern && pattern[0] == 'X')
1767                 m->specificity = 0x0a00;
1768         else if (specificity == 1 && is_pattern && pattern[0] == '.')
1769                 m->specificity = 0x10000;
1770         else if (specificity == 1 && is_pattern && pattern[0] == '!')
1771                 m->specificity = 0x20000;
1772         else
1773                 m->specificity = specificity;
1774         
1775         if (!con->pattern_tree) {
1776                 insert_in_next_chars_alt_char_list(&con->pattern_tree, m);
1777         } else {
1778                 if (already) { /* switch to the new regime (traversing vs appending)*/
1779                         insert_in_next_chars_alt_char_list(nextcharptr, m);
1780                 } else {
1781                         insert_in_next_chars_alt_char_list(&current->next_char, m);
1782                 }
1783         }
1784
1785         return m;
1786 }
1787
1788 static struct match_char *add_exten_to_pattern_tree(struct ast_context *con, struct ast_exten *e1, int findonly)
1789 {
1790         struct match_char *m1 = NULL, *m2 = NULL, **m0;
1791         int specif;
1792         int already;
1793         int pattern = 0;
1794         char buf[256];
1795         char extenbuf[512];
1796         char *s1 = extenbuf;
1797         int l1 = strlen(e1->exten) + strlen(e1->cidmatch) + 2;
1798         
1799
1800         strncpy(extenbuf,e1->exten,sizeof(extenbuf));
1801         if (e1->matchcid &&  l1 <= sizeof(extenbuf)) {
1802                 strcat(extenbuf,"/");
1803                 strcat(extenbuf,e1->cidmatch);
1804         } else if (l1 > sizeof(extenbuf)) {
1805                 ast_log(LOG_ERROR,"The pattern %s/%s is too big to deal with: it will be ignored! Disaster!\n", e1->exten, e1->cidmatch);
1806                 return 0;
1807         }
1808 #ifdef NEED_DEBUG
1809         ast_log(LOG_DEBUG,"Adding exten %s%c%s to tree\n", s1, e1->matchcid? '/':' ', e1->matchcid? e1->cidmatch : "");
1810 #endif
1811         m1 = con->pattern_tree; /* each pattern starts over at the root of the pattern tree */
1812         m0 = &con->pattern_tree;
1813         already = 1;
1814
1815         if ( *s1 == '_') {
1816                 pattern = 1;
1817                 s1++;
1818         }
1819         while( *s1 ) {
1820                 if (pattern && *s1 == '[' && *(s1-1) != '\\') {
1821                         char *s2 = buf;
1822                         buf[0] = 0;
1823                         s1++; /* get past the '[' */
1824                         while (*s1 != ']' && *(s1-1) != '\\' ) {
1825                                 if (*s1 == '\\') {
1826                                         if (*(s1+1) == ']') {
1827                                                 *s2++ = ']';
1828                                                 s1++;s1++;
1829                                         } else if (*(s1+1) == '\\') {
1830                                                 *s2++ = '\\';
1831                                                 s1++;s1++;
1832                                         } else if (*(s1+1) == '-') {
1833                                                 *s2++ = '-';
1834                                                 s1++; s1++;
1835                                         } else if (*(s1+1) == '[') {
1836                                                 *s2++ = '[';
1837                                                 s1++; s1++;
1838                                         }
1839                                 } else if (*s1 == '-') { /* remember to add some error checking to all this! */
1840                                         char s3 = *(s1-1);
1841                                         char s4 = *(s1+1);
1842                                         for (s3++; s3 <= s4; s3++) {
1843                                                 *s2++ = s3;
1844                                         }
1845                                         s1++; s1++;
1846                                 } else {
1847                                         *s2++ = *s1++;
1848                                 }
1849                         }
1850                         *s2 = 0; /* null terminate the exploded range */
1851                         /* sort the characters */
1852
1853                         specif = strlen(buf);
1854                         qsort(buf, specif, 1, compare_char);
1855                         specif <<= 8;
1856                         specif += buf[0];
1857                 } else {
1858                         
1859                         if (*s1 == '\\') {
1860                                 s1++;
1861                                 buf[0] = *s1;
1862                         } else {
1863                                 if (pattern) {
1864                                         if (*s1 == 'n') /* make sure n,x,z patterns are canonicalized to N,X,Z */
1865                                                 *s1 = 'N';
1866                                         else if (*s1 == 'x')
1867                                                 *s1 = 'X';
1868                                         else if (*s1 == 'z')
1869                                                 *s1 = 'Z';
1870                                 }
1871                                 buf[0] = *s1;
1872                         }
1873                         buf[1] = 0;
1874                         specif = 1;
1875                 }
1876                 m2 = 0;
1877                 if (already && (m2=already_in_tree(m1,buf)) && m2->next_char) {
1878                         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...
1879                                                                 a shorter pattern might win if the longer one doesn't match */
1880                                 m2->exten = e1;
1881                                 m2->deleted = 0;
1882                         }
1883                         m1 = m2->next_char; /* m1 points to the node to compare against */
1884                         m0 = &m2->next_char; /* m0 points to the ptr that points to m1 */
1885                 } else { /* not already OR not m2 OR nor m2->next_char */
1886                         if (m2) {
1887                                 if (findonly)
1888                                         return m2;
1889                                 m1 = m2; /* while m0 stays the same */
1890                         } else {
1891                                 if (findonly)
1892                                         return m1;
1893                                 m1 = add_pattern_node(con, m1, buf, pattern, already,specif, m0); /* m1 is the node just added */
1894                                 m0 = &m1->next_char;
1895                         }
1896                         
1897                         if (!(*(s1+1))) {
1898                                 m1->deleted = 0;
1899                                 m1->exten = e1;
1900                         }
1901                         
1902                         already = 0;
1903                 }
1904                 s1++; /* advance to next char */
1905         }
1906         return m1;
1907 }
1908
1909 static void create_match_char_tree(struct ast_context *con)
1910 {
1911         struct ast_hashtab_iter *t1;
1912         struct ast_exten *e1;
1913 #ifdef NEED_DEBUG
1914         int biggest_bucket, resizes, numobjs, numbucks;
1915         
1916         ast_log(LOG_DEBUG,"Creating Extension Trie for context %s\n", con->name);
1917         ast_hashtab_get_stats(con->root_table, &biggest_bucket, &resizes, &numobjs, &numbucks);
1918         ast_log(LOG_DEBUG,"This tree has %d objects in %d bucket lists, longest list=%d objects, and has resized %d times\n",
1919                         numobjs, numbucks, biggest_bucket, resizes);
1920 #endif
1921         t1 = ast_hashtab_start_traversal(con->root_table);
1922         while( (e1 = ast_hashtab_next(t1)) ) {
1923                 if (e1->exten)
1924                         add_exten_to_pattern_tree(con, e1, 0);
1925                 else
1926                         ast_log(LOG_ERROR,"Attempt to create extension with no extension name.\n");
1927         }
1928         ast_hashtab_end_traversal(t1);
1929 }
1930
1931 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! */
1932 {
1933         /* destroy all the alternates */
1934         if (pattern_tree->alt_char) {
1935                 destroy_pattern_tree(pattern_tree->alt_char);
1936                 pattern_tree->alt_char = 0;
1937         }
1938         /* destroy all the nexts */
1939         if (pattern_tree->next_char) {
1940                 destroy_pattern_tree(pattern_tree->next_char);
1941                 pattern_tree->next_char = 0;
1942         }
1943         pattern_tree->exten = 0; /* never hurts to make sure there's no pointers laying around */
1944         if (pattern_tree->x)
1945                 free(pattern_tree->x);
1946         free(pattern_tree);
1947 }
1948
1949 /*
1950  * Special characters used in patterns:
1951  *      '_'     underscore is the leading character of a pattern.
1952  *              In other position it is treated as a regular char.
1953  *      ' ' '-' space and '-' are separator and ignored.
1954  *      .       one or more of any character. Only allowed at the end of
1955  *              a pattern.
1956  *      !       zero or more of anything. Also impacts the result of CANMATCH
1957  *              and MATCHMORE. Only allowed at the end of a pattern.
1958  *              In the core routine, ! causes a match with a return code of 2.
1959  *              In turn, depending on the search mode: (XXX check if it is implemented)
1960  *              - E_MATCH retuns 1 (does match)
1961  *              - E_MATCHMORE returns 0 (no match)
1962  *              - E_CANMATCH returns 1 (does match)
1963  *
1964  *      /       should not appear as it is considered the separator of the CID info.
1965  *              XXX at the moment we may stop on this char.
1966  *
1967  *      X Z N   match ranges 0-9, 1-9, 2-9 respectively.
1968  *      [       denotes the start of a set of character. Everything inside
1969  *              is considered literally. We can have ranges a-d and individual
1970  *              characters. A '[' and '-' can be considered literally if they
1971  *              are just before ']'.
1972  *              XXX currently there is no way to specify ']' in a range, nor \ is
1973  *              considered specially.
1974  *
1975  * When we compare a pattern with a specific extension, all characters in the extension
1976  * itself are considered literally with the only exception of '-' which is considered
1977  * as a separator and thus ignored.
1978  * XXX do we want to consider space as a separator as well ?
1979  * XXX do we want to consider the separators in non-patterns as well ?
1980  */
1981
1982 /*!
1983  * \brief helper functions to sort extensions and patterns in the desired way,
1984  * so that more specific patterns appear first.
1985  *
1986  * ext_cmp1 compares individual characters (or sets of), returning
1987  * an int where bits 0-7 are the ASCII code of the first char in the set,
1988  * while bit 8-15 are the cardinality of the set minus 1.
1989  * This way more specific patterns (smaller cardinality) appear first.
1990  * Wildcards have a special value, so that we can directly compare them to
1991  * sets by subtracting the two values. In particular:
1992  *      0x000xx         one character, xx
1993  *      0x0yyxx         yy character set starting with xx
1994  *      0x10000         '.' (one or more of anything)
1995  *      0x20000         '!' (zero or more of anything)
1996  *      0x30000         NUL (end of string)
1997  *      0x40000         error in set.
1998  * The pointer to the string is advanced according to needs.
1999  * NOTES:
2000  *      1. the empty set is equivalent to NUL.
2001  *      2. given that a full set has always 0 as the first element,
2002  *         we could encode the special cases as 0xffXX where XX
2003  *         is 1, 2, 3, 4 as used above.
2004  */
2005 static int ext_cmp1(const char **p)
2006 {
2007         uint32_t chars[8];
2008         int c, cmin = 0xff, count = 0;
2009         const char *end;
2010
2011         /* load, sign extend and advance pointer until we find
2012          * a valid character.
2013          */
2014         while ( (c = *(*p)++) && (c == ' ' || c == '-') )
2015                 ;       /* ignore some characters */
2016
2017         /* always return unless we have a set of chars */
2018         switch (toupper(c)) {
2019         default:        /* ordinary character */
2020                 return 0x0000 | (c & 0xff);
2021
2022         case 'N':       /* 2..9 */
2023                 return 0x0700 | '2' ;
2024
2025         case 'X':       /* 0..9 */
2026                 return 0x0900 | '0';
2027
2028         case 'Z':       /* 1..9 */
2029                 return 0x0800 | '1';
2030
2031         case '.':       /* wildcard */
2032                 return 0x10000;
2033
2034         case '!':       /* earlymatch */
2035                 return 0x20000; /* less specific than NULL */
2036
2037         case '\0':      /* empty string */
2038                 *p = NULL;
2039                 return 0x30000;
2040
2041         case '[':       /* pattern */
2042                 break;
2043         }
2044         /* locate end of set */
2045         end = strchr(*p, ']');  
2046
2047         if (end == NULL) {
2048                 ast_log(LOG_WARNING, "Wrong usage of [] in the extension\n");
2049                 return 0x40000; /* XXX make this entry go last... */
2050         }
2051
2052         memset(chars, '\0', sizeof(chars));     /* clear all chars in the set */
2053         for (; *p < end  ; (*p)++) {
2054                 unsigned char c1, c2;   /* first-last char in range */
2055                 c1 = (unsigned char)((*p)[0]);
2056                 if (*p + 2 < end && (*p)[1] == '-') { /* this is a range */
2057                         c2 = (unsigned char)((*p)[2]);
2058                         *p += 2;        /* skip a total of 3 chars */
2059                 } else                  /* individual character */
2060                         c2 = c1;
2061                 if (c1 < cmin)
2062                         cmin = c1;
2063                 for (; c1 <= c2; c1++) {
2064                         uint32_t mask = 1 << (c1 % 32);
2065                         if ( (chars[ c1 / 32 ] & mask) == 0)
2066                                 count += 0x100;
2067                         chars[ c1 / 32 ] |= mask;
2068                 }
2069         }
2070         (*p)++;
2071         return count == 0 ? 0x30000 : (count | cmin);
2072 }
2073
2074 /*!
2075  * \brief the full routine to compare extensions in rules.
2076  */
2077 static int ext_cmp(const char *a, const char *b)
2078 {
2079         /* make sure non-patterns come first.
2080          * If a is not a pattern, it either comes first or
2081          * we use strcmp to compare the strings.
2082          */
2083         int ret = 0;
2084
2085         if (a[0] != '_')
2086                 return (b[0] == '_') ? -1 : strcmp(a, b);
2087
2088         /* Now we know a is a pattern; if b is not, a comes first */
2089         if (b[0] != '_')
2090                 return 1;
2091 #if 0   /* old mode for ext matching */
2092         return strcmp(a, b);
2093 #endif
2094         /* ok we need full pattern sorting routine */
2095         while (!ret && a && b)
2096                 ret = ext_cmp1(&a) - ext_cmp1(&b);
2097         if (ret == 0)
2098                 return 0;
2099         else
2100                 return (ret > 0) ? 1 : -1;
2101 }
2102
2103 int ast_extension_cmp(const char *a, const char *b)
2104 {
2105         return ext_cmp(a, b);
2106 }
2107
2108 /*!
2109  * \internal
2110  * \brief used ast_extension_{match|close}
2111  * mode is as follows:
2112  *      E_MATCH         success only on exact match
2113  *      E_MATCHMORE     success only on partial match (i.e. leftover digits in pattern)
2114  *      E_CANMATCH      either of the above.
2115  * \retval 0 on no-match
2116  * \retval 1 on match
2117  * \retval 2 on early match.
2118  */
2119
2120 static int _extension_match_core(const char *pattern, const char *data, enum ext_match_t mode)
2121 {
2122         mode &= E_MATCH_MASK;   /* only consider the relevant bits */
2123         
2124 #ifdef NEED_DEBUG_HERE
2125         ast_log(LOG_NOTICE,"match core: pat: '%s', dat: '%s', mode=%d\n", pattern, data, (int)mode);
2126 #endif
2127         
2128         if ( (mode == E_MATCH) && (pattern[0] == '_') && (!strcasecmp(pattern,data)) ) { /* note: if this test is left out, then _x. will not match _x. !!! */
2129 #ifdef NEED_DEBUG_HERE
2130                 ast_log(LOG_NOTICE,"return (1) - pattern matches pattern\n");
2131 #endif
2132                 return 1;
2133         }
2134
2135         if (pattern[0] != '_') { /* not a pattern, try exact or partial match */
2136                 int ld = strlen(data), lp = strlen(pattern);
2137                 
2138                 if (lp < ld) {          /* pattern too short, cannot match */
2139 #ifdef NEED_DEBUG_HERE
2140                         ast_log(LOG_NOTICE,"return (0) - pattern too short, cannot match\n");
2141 #endif
2142                         return 0;
2143                 }
2144                 /* depending on the mode, accept full or partial match or both */
2145                 if (mode == E_MATCH) {
2146 #ifdef NEED_DEBUG_HERE
2147                         ast_log(LOG_NOTICE,"return (!strcmp(%s,%s) when mode== E_MATCH)\n", pattern, data);
2148 #endif
2149                         return !strcmp(pattern, data); /* 1 on match, 0 on fail */
2150                 } 
2151                 if (ld == 0 || !strncasecmp(pattern, data, ld)) { /* partial or full match */
2152 #ifdef NEED_DEBUG_HERE
2153                         ast_log(LOG_NOTICE,"return (mode(%d) == E_MATCHMORE ? lp(%d) > ld(%d) : 1)\n", mode, lp, ld);
2154 #endif
2155                         return (mode == E_MATCHMORE) ? lp > ld : 1; /* XXX should consider '!' and '/' ? */
2156                 } else {
2157 #ifdef NEED_DEBUG_HERE
2158                         ast_log(LOG_NOTICE,"return (0) when ld(%d) > 0 && pattern(%s) != data(%s)\n", ld, pattern, data);
2159 #endif
2160                         return 0;
2161                 }
2162         }
2163         pattern++; /* skip leading _ */
2164         /*
2165          * XXX below we stop at '/' which is a separator for the CID info. However we should
2166          * not store '/' in the pattern at all. When we insure it, we can remove the checks.
2167          */
2168         while (*data && *pattern && *pattern != '/') {
2169                 const char *end;
2170
2171                 if (*data == '-') { /* skip '-' in data (just a separator) */
2172                         data++;
2173                         continue;
2174                 }
2175                 switch (toupper(*pattern)) {
2176                 case '[':       /* a range */
2177                         end = strchr(pattern+1, ']'); /* XXX should deal with escapes ? */
2178                         if (end == NULL) {
2179                                 ast_log(LOG_WARNING, "Wrong usage of [] in the extension\n");
2180                                 return 0;       /* unconditional failure */
2181                         }
2182                         for (pattern++; pattern != end; pattern++) {
2183                                 if (pattern+2 < end && pattern[1] == '-') { /* this is a range */
2184                                         if (*data >= pattern[0] && *data <= pattern[2])
2185                                                 break;  /* match found */
2186                                         else {
2187                                                 pattern += 2; /* skip a total of 3 chars */
2188                                                 continue;
2189                                         }
2190                                 } else if (*data == pattern[0])
2191                                         break;  /* match found */
2192                         }
2193                         if (pattern == end) {
2194 #ifdef NEED_DEBUG_HERE
2195                                 ast_log(LOG_NOTICE,"return (0) when pattern==end\n");
2196 #endif
2197                                 return 0;
2198                         }
2199                         pattern = end;  /* skip and continue */
2200                         break;
2201                 case 'N':
2202                         if (*data < '2' || *data > '9') {
2203 #ifdef NEED_DEBUG_HERE
2204                                 ast_log(LOG_NOTICE,"return (0) N is matched\n");
2205 #endif
2206                                 return 0;
2207                         }
2208                         break;
2209                 case 'X':
2210                         if (*data < '0' || *data > '9') {
2211 #ifdef NEED_DEBUG_HERE
2212                                 ast_log(LOG_NOTICE,"return (0) X is matched\n");
2213 #endif
2214                                 return 0;
2215                         }
2216                         break;
2217                 case 'Z':
2218                         if (*data < '1' || *data > '9') {
2219 #ifdef NEED_DEBUG_HERE
2220                                 ast_log(LOG_NOTICE,"return (0) Z is matched\n");
2221 #endif
2222                                 return 0;
2223                         }
2224                         break;
2225                 case '.':       /* Must match, even with more digits */
2226 #ifdef NEED_DEBUG_HERE
2227                         ast_log(LOG_NOTICE,"return (1) when '.' is matched\n");
2228 #endif
2229                         return 1;
2230                 case '!':       /* Early match */
2231 #ifdef NEED_DEBUG_HERE
2232                         ast_log(LOG_NOTICE,"return (2) when '!' is matched\n");
2233 #endif
2234                         return 2;
2235                 case ' ':
2236                 case '-':       /* Ignore these in patterns */
2237                         data--; /* compensate the final data++ */
2238                         break;
2239                 default:
2240                         if (*data != *pattern) {
2241 #ifdef NEED_DEBUG_HERE
2242                                 ast_log(LOG_NOTICE,"return (0) when *data(%c) != *pattern(%c)\n", *data, *pattern);
2243 #endif
2244                                 return 0;
2245                         }
2246                         
2247                 }
2248                 data++;
2249                 pattern++;
2250         }
2251         if (*data)                      /* data longer than pattern, no match */ {
2252 #ifdef NEED_DEBUG_HERE
2253                 ast_log(LOG_NOTICE,"return (0) when data longer than pattern\n");
2254 #endif
2255                 return 0;
2256         }
2257         
2258         /*
2259          * match so far, but ran off the end of the data.
2260          * Depending on what is next, determine match or not.
2261          */
2262         if (*pattern == '\0' || *pattern == '/') {      /* exact match */
2263 #ifdef NEED_DEBUG_HERE
2264                 ast_log(LOG_NOTICE,"at end, return (%d) in 'exact match'\n", (mode==E_MATCHMORE) ? 0 : 1);
2265 #endif
2266                 return (mode == E_MATCHMORE) ? 0 : 1;   /* this is a failure for E_MATCHMORE */
2267         } else if (*pattern == '!')     {               /* early match */
2268 #ifdef NEED_DEBUG_HERE
2269                 ast_log(LOG_NOTICE,"at end, return (2) when '!' is matched\n");
2270 #endif
2271                 return 2;
2272         } else {                                                /* partial match */
2273 #ifdef NEED_DEBUG_HERE
2274                 ast_log(LOG_NOTICE,"at end, return (%d) which deps on E_MATCH\n", (mode == E_MATCH) ? 0 : 1);
2275 #endif
2276                 return (mode == E_MATCH) ? 0 : 1;       /* this is a failure for E_MATCH */
2277         }
2278 }
2279
2280 /*
2281  * Wrapper around _extension_match_core() to do performance measurement
2282  * using the profiling code.
2283  */
2284 static int extension_match_core(const char *pattern, const char *data, enum ext_match_t mode)
2285 {
2286         int i;
2287         static int prof_id = -2;        /* marker for 'unallocated' id */
2288         if (prof_id == -2)
2289                 prof_id = ast_add_profile("ext_match", 0);
2290         ast_mark(prof_id, 1);
2291         i = _extension_match_core(pattern, data, mode);
2292         ast_mark(prof_id, 0);
2293         return i;
2294 }
2295
2296 int ast_extension_match(const char *pattern, const char *data)
2297 {
2298         return extension_match_core(pattern, data, E_MATCH);
2299 }
2300
2301 int ast_extension_close(const char *pattern, const char *data, int needmore)
2302 {
2303         if (needmore != E_MATCHMORE && needmore != E_CANMATCH)
2304                 ast_log(LOG_WARNING, "invalid argument %d\n", needmore);
2305         return extension_match_core(pattern, data, needmore);
2306 }
2307
2308 struct fake_context /* this struct is purely for matching in the hashtab */
2309 {
2310         ast_rwlock_t lock;                      
2311         struct ast_exten *root;         
2312         struct ast_hashtab *root_table;            
2313         struct match_char *pattern_tree;       
2314         struct ast_context *next;       
2315         struct ast_include *includes;           
2316         struct ast_ignorepat *ignorepats;       
2317         const char *registrar;
2318         int refcount;
2319         AST_LIST_HEAD_NOLOCK(, ast_sw) alts;    
2320         ast_mutex_t macrolock;          
2321         char name[256];         
2322 };
2323
2324 struct ast_context *ast_context_find(const char *name)
2325 {
2326         struct ast_context *tmp = NULL;
2327         struct fake_context item;
2328         strncpy(item.name,name,256);
2329         ast_rdlock_contexts();
2330         if( contexts_table ) {
2331                 tmp = ast_hashtab_lookup(contexts_table,&item);
2332         } else {
2333                 while ( (tmp = ast_walk_contexts(tmp)) ) {
2334                         if (!name || !strcasecmp(name, tmp->name))
2335                                 break;
2336                 }
2337         }
2338         ast_unlock_contexts();
2339         return tmp;
2340 }
2341
2342 #define STATUS_NO_CONTEXT       1
2343 #define STATUS_NO_EXTENSION     2
2344 #define STATUS_NO_PRIORITY      3
2345 #define STATUS_NO_LABEL         4
2346 #define STATUS_SUCCESS          5
2347
2348 static int matchcid(const char *cidpattern, const char *callerid)
2349 {
2350         /* If the Caller*ID pattern is empty, then we're matching NO Caller*ID, so
2351            failing to get a number should count as a match, otherwise not */
2352
2353         if (ast_strlen_zero(callerid))
2354                 return ast_strlen_zero(cidpattern) ? 1 : 0;
2355
2356         return ast_extension_match(cidpattern, callerid);
2357 }
2358
2359 struct ast_exten *pbx_find_extension(struct ast_channel *chan,
2360         struct ast_context *bypass, struct pbx_find_info *q,
2361         const char *context, const char *exten, int priority,
2362         const char *label, const char *callerid, enum ext_match_t action)
2363 {
2364         int x, res;
2365         struct ast_context *tmp = NULL;
2366         struct ast_exten *e = NULL, *eroot = NULL;
2367         struct ast_include *i = NULL;
2368         struct ast_sw *sw = NULL;
2369         struct ast_exten pattern = {NULL, };
2370         struct scoreboard score = {0, };
2371         struct ast_str *tmpdata = NULL;
2372
2373         pattern.label = label;
2374         pattern.priority = priority;
2375 #ifdef NEED_DEBUG_HERE
2376         ast_log(LOG_NOTICE,"Looking for cont/ext/prio/label/action = %s/%s/%d/%s/%d\n", context, exten, priority, label, (int)action);
2377 #endif
2378
2379         if (ast_strlen_zero(exten))
2380                 return NULL;
2381
2382         /* Initialize status if appropriate */
2383         if (q->stacklen == 0) {
2384                 q->status = STATUS_NO_CONTEXT;
2385                 q->swo = NULL;
2386                 q->data = NULL;
2387                 q->foundcontext = NULL;
2388         } else if (q->stacklen >= AST_PBX_MAX_STACK) {
2389                 ast_log(LOG_WARNING, "Maximum PBX stack exceeded\n");
2390                 return NULL;
2391         }
2392
2393         /* Check first to see if we've already been checked */
2394         for (x = 0; x < q->stacklen; x++) {
2395                 if (!strcasecmp(q->incstack[x], context))
2396                         return NULL;
2397         }
2398
2399         if (bypass)     /* bypass means we only look there */
2400                 tmp = bypass;
2401         else {  /* look in contexts */
2402                 struct fake_context item;
2403                 strncpy(item.name,context,256);
2404                 tmp = ast_hashtab_lookup(contexts_table,&item);
2405 #ifdef NOTNOW
2406                 tmp = NULL;
2407                 while ((tmp = ast_walk_contexts(tmp)) ) {
2408                         if (!strcmp(tmp->name, context))
2409                                 break;
2410                 }
2411 #endif
2412                 if (!tmp)
2413                         return NULL;
2414                 
2415         }
2416
2417         if (q->status < STATUS_NO_EXTENSION)
2418                 q->status = STATUS_NO_EXTENSION;
2419         
2420         /* Do a search for matching extension */
2421
2422         eroot = NULL;
2423         score.total_specificity = 0;
2424         score.exten = 0;
2425         score.total_length = 0;
2426         if (!tmp->pattern_tree && tmp->root_table)
2427         {
2428                 create_match_char_tree(tmp);
2429 #ifdef NEED_DEBUG
2430                 ast_log(LOG_DEBUG,"Tree Created in context %s:\n", context);
2431                 log_match_char_tree(tmp->pattern_tree," ");
2432 #endif
2433         }
2434 #ifdef NEED_DEBUG
2435         ast_log(LOG_NOTICE,"The Trie we are searching in:\n");
2436         log_match_char_tree(tmp->pattern_tree, "::  ");
2437 #endif
2438
2439         do {
2440                 if (!ast_strlen_zero(overrideswitch)) {
2441                         char *osw = ast_strdupa(overrideswitch), *name;
2442                         struct ast_switch *asw;
2443                         ast_switch_f *aswf = NULL;
2444                         char *datap;
2445                         int eval = 0;
2446
2447                         name = strsep(&osw, "/");
2448                         asw = pbx_findswitch(name);
2449
2450                         if (!asw) {
2451                                 ast_log(LOG_WARNING, "No such switch '%s'\n", name);
2452                                 break;
2453                         }
2454
2455                         if (osw && strchr(osw, '$')) {
2456                                 eval = 1;
2457                         }
2458
2459                         if (eval && !(tmpdata = ast_str_thread_get(&switch_data, 512))) {
2460                                 ast_log(LOG_WARNING, "Can't evaluate overrideswitch?!");
2461                                 break;
2462                         } else if (eval) {
2463                                 /* Substitute variables now */
2464                                 pbx_substitute_variables_helper(chan, osw, tmpdata->str, tmpdata->len);
2465                                 datap = tmpdata->str;
2466                         } else {
2467                                 datap = osw;
2468                         }
2469
2470                         /* equivalent of extension_match_core() at the switch level */
2471                         if (action == E_CANMATCH)
2472                                 aswf = asw->canmatch;
2473                         else if (action == E_MATCHMORE)
2474                                 aswf = asw->matchmore;
2475                         else /* action == E_MATCH */
2476                                 aswf = asw->exists;
2477                         if (!aswf) {
2478                                 res = 0;
2479                         } else {
2480                                 if (chan) {
2481                                         ast_autoservice_start(chan);
2482                                 }
2483                                 res = aswf(chan, context, exten, priority, callerid, datap);
2484                                 if (chan) {
2485                                         ast_autoservice_stop(chan);
2486                                 }
2487                         }
2488                         if (res) {      /* Got a match */
2489                                 q->swo = asw;
2490                                 q->data = datap;
2491                                 q->foundcontext = context;
2492                                 /* XXX keep status = STATUS_NO_CONTEXT ? */
2493                                 return NULL;
2494                         }
2495                 }
2496         } while (0);
2497
2498         if (extenpatternmatchnew) {
2499                 new_find_extension(exten, &score, tmp->pattern_tree, 0, 0, callerid, label, action);
2500                 eroot = score.exten;
2501                 
2502                 if (score.last_char == '!' && action == E_MATCHMORE) {
2503                         /* We match an extension ending in '!'.
2504                          * The decision in this case is final and is NULL (no match).
2505                          */
2506 #ifdef NEED_DEBUG_HERE
2507                         ast_log(LOG_NOTICE,"Returning MATCHMORE NULL with exclamation point.\n");
2508 #endif
2509                         return NULL;
2510                 }
2511                 
2512                 if (!eroot && (action == E_CANMATCH || action == E_MATCHMORE) && score.canmatch_exten) {
2513                         q->status = STATUS_SUCCESS;
2514 #ifdef NEED_DEBUG_HERE
2515                         ast_log(LOG_NOTICE,"Returning CANMATCH exten %s\n", score.canmatch_exten->exten);
2516 #endif
2517                         return score.canmatch_exten;
2518                 }
2519                 
2520                 if ((action == E_MATCHMORE || action == E_CANMATCH)  && eroot) {
2521                         if (score.node) {
2522                                 struct ast_exten *z = trie_find_next_match(score.node);
2523                                 if (z) {
2524 #ifdef NEED_DEBUG_HERE
2525                                         ast_log(LOG_NOTICE,"Returning CANMATCH/MATCHMORE next_match exten %s\n", z->exten);
2526 #endif
2527                                 } else {
2528                                         if (score.canmatch_exten) {
2529 #ifdef NEED_DEBUG_HERE
2530                                                 ast_log(LOG_NOTICE,"Returning CANMATCH/MATCHMORE canmatchmatch exten %s(%p)\n", score.canmatch_exten->exten, score.canmatch_exten);
2531 #endif
2532                                                 return score.canmatch_exten;
2533                                         } else {
2534 #ifdef NEED_DEBUG_HERE
2535                                                 ast_log(LOG_NOTICE,"Returning CANMATCH/MATCHMORE next_match exten NULL\n");
2536 #endif
2537                                         }
2538                                 }
2539                                 return z;
2540                         }
2541 #ifdef NEED_DEBUG_HERE
2542                         ast_log(LOG_NOTICE,"Returning CANMATCH/MATCHMORE NULL (no next_match)\n");
2543 #endif
2544                         return NULL;  /* according to the code, complete matches are null matches in MATCHMORE mode */
2545                 }
2546                 
2547                 if (eroot) {
2548                         /* found entry, now look for the right priority */
2549                         if (q->status < STATUS_NO_PRIORITY)
2550                                 q->status = STATUS_NO_PRIORITY;
2551                         e = NULL;
2552                         if (action == E_FINDLABEL && label ) {
2553                                 if (q->status < STATUS_NO_LABEL)
2554                                         q->status = STATUS_NO_LABEL;
2555                                 e = ast_hashtab_lookup(eroot->peer_label_table, &pattern);
2556                         } else {
2557                                 e = ast_hashtab_lookup(eroot->peer_table, &pattern);
2558                         }
2559                         if (e) {        /* found a valid match */
2560                                 q->status = STATUS_SUCCESS;
2561                                 q->foundcontext = context;
2562 #ifdef NEED_DEBUG_HERE
2563                                 ast_log(LOG_NOTICE,"Returning complete match of exten %s\n", e->exten);
2564 #endif
2565                                 return e;
2566                         }
2567                 }
2568         } else {   /* the old/current default exten pattern match algorithm */
2569                 
2570                 /* scan the list trying to match extension and CID */
2571                 eroot = NULL;
2572                 while ( (eroot = ast_walk_context_extensions(tmp, eroot)) ) {
2573                         int match = extension_match_core(eroot->exten, exten, action);
2574                         /* 0 on fail, 1 on match, 2 on earlymatch */
2575                         
2576                         if (!match || (eroot->matchcid && !matchcid(eroot->cidmatch, callerid)))
2577                                 continue;       /* keep trying */
2578                         if (match == 2 && action == E_MATCHMORE) {
2579                                 /* We match an extension ending in '!'.
2580                                  * The decision in this case is final and is NULL (no match).
2581                                  */
2582                                 return NULL;
2583                         }
2584                         /* found entry, now look for the right priority */
2585                         if (q->status < STATUS_NO_PRIORITY)
2586                                 q->status = STATUS_NO_PRIORITY;
2587                         e = NULL;
2588                         if (action == E_FINDLABEL && label ) {
2589                                 if (q->status < STATUS_NO_LABEL)
2590                                         q->status = STATUS_NO_LABEL;
2591                                 e = ast_hashtab_lookup(eroot->peer_label_table, &pattern);
2592                         } else {
2593                                 e = ast_hashtab_lookup(eroot->peer_table, &pattern);
2594                         }
2595 #ifdef NOTNOW
2596                         while ( (e = ast_walk_extension_priorities(eroot, e)) ) {
2597                                 /* Match label or priority */
2598                                 if (action == E_FINDLABEL) {
2599                                         if (q->status < STATUS_NO_LABEL)
2600                                                 q->status = STATUS_NO_LABEL;
2601                                         if (label && e->label && !strcmp(label, e->label))
2602                                                 break;  /* found it */
2603                                 } else if (e->priority == priority) {
2604                                         break;  /* found it */
2605                                 } /* else keep searching */
2606                         }
2607 #endif
2608                         if (e) {        /* found a valid match */
2609                                 q->status = STATUS_SUCCESS;
2610                                 q->foundcontext = context;
2611                                 return e;
2612                         }
2613                 }
2614         }
2615         
2616         
2617         /* Check alternative switches */
2618         AST_LIST_TRAVERSE(&tmp->alts, sw, list) {
2619                 struct ast_switch *asw = pbx_findswitch(sw->name);
2620                 ast_switch_f *aswf = NULL;
2621                 char *datap;
2622
2623                 if (!asw) {
2624                         ast_log(LOG_WARNING, "No such switch '%s'\n", sw->name);
2625                         continue;
2626                 }
2627                 /* Substitute variables now */
2628                 
2629                 if (sw->eval) {
2630                         if (!(tmpdata = ast_str_thread_get(&switch_data, 512))) {
2631                                 ast_log(LOG_WARNING, "Can't evaluate switch?!");
2632                                 continue;
2633                         }
2634                         pbx_substitute_variables_helper(chan, sw->data, tmpdata->str, tmpdata->len);
2635                 }
2636
2637                 /* equivalent of extension_match_core() at the switch level */
2638                 if (action == E_CANMATCH)
2639                         aswf = asw->canmatch;
2640                 else if (action == E_MATCHMORE)
2641                         aswf = asw->matchmore;
2642                 else /* action == E_MATCH */
2643                         aswf = asw->exists;
2644                 datap = sw->eval ? tmpdata->str : sw->data;
2645                 if (!aswf)
2646                         res = 0;
2647                 else {
2648                         if (chan)
2649                                 ast_autoservice_start(chan);
2650                         res = aswf(chan, context, exten, priority, callerid, datap);
2651                         if (chan)
2652                                 ast_autoservice_stop(chan);
2653                 }
2654                 if (res) {      /* Got a match */
2655                         q->swo = asw;
2656                         q->data = datap;
2657                         q->foundcontext = context;
2658                         /* XXX keep status = STATUS_NO_CONTEXT ? */
2659                         return NULL;
2660                 }
2661         }
2662         q->incstack[q->stacklen++] = tmp->name; /* Setup the stack */
2663         /* Now try any includes we have in this context */
2664         for (i = tmp->includes; i; i = i->next) {
2665                 if (include_valid(i)) {
2666                         if ((e = pbx_find_extension(chan, bypass, q, i->rname, exten, priority, label, callerid, action))) {
2667 #ifdef NEED_DEBUG_HERE
2668                                 ast_log(LOG_NOTICE,"Returning recursive match of %s\n", e->exten);
2669 #endif
2670                                 return e;
2671                         }
2672                         if (q->swo)
2673                                 return NULL;
2674                 }
2675         }
2676         return NULL;
2677 }
2678
2679 /*! 
2680  * \brief extract offset:length from variable name.
2681  * \return 1 if there is a offset:length part, which is
2682  * trimmed off (values go into variables)
2683  */
2684 static int parse_variable_name(char *var, int *offset, int *length, int *isfunc)
2685 {
2686         int parens = 0;
2687
2688         *offset = 0;
2689         *length = INT_MAX;
2690         *isfunc = 0;
2691         for (; *var; var++) {
2692                 if (*var == '(') {
2693                         (*isfunc)++;
2694                         parens++;
2695                 } else if (*var == ')') {
2696                         parens--;
2697                 } else if (*var == ':' && parens == 0) {
2698                         *var++ = '\0';
2699                         sscanf(var, "%d:%d", offset, length);
2700                         return 1; /* offset:length valid */
2701                 }
2702         }
2703         return 0;
2704 }
2705
2706 /*! 
2707  *\brief takes a substring. It is ok to call with value == workspace.
2708  * \param value
2709  * \param offset < 0 means start from the end of the string and set the beginning
2710  *   to be that many characters back.
2711  * \param length is the length of the substring, a value less than 0 means to leave
2712  * that many off the end.
2713  * \param workspace
2714  * \param workspace_len
2715  * Always return a copy in workspace.
2716  */
2717 static char *substring(const char *value, int offset, int length, char *workspace, size_t workspace_len)
2718 {
2719         char *ret = workspace;
2720         int lr; /* length of the input string after the copy */
2721
2722         ast_copy_string(workspace, value, workspace_len); /* always make a copy */
2723
2724         lr = strlen(ret); /* compute length after copy, so we never go out of the workspace */
2725
2726         /* Quick check if no need to do anything */
2727         if (offset == 0 && length >= lr)        /* take the whole string */
2728                 return ret;
2729
2730         if (offset < 0) {       /* translate negative offset into positive ones */
2731                 offset = lr + offset;
2732                 if (offset < 0) /* If the negative offset was greater than the length of the string, just start at the beginning */
2733                         offset = 0;
2734         }
2735
2736         /* too large offset result in empty string so we know what to return */
2737         if (offset >= lr)
2738                 return ret + lr;        /* the final '\0' */
2739
2740         ret += offset;          /* move to the start position */
2741         if (length >= 0 && length < lr - offset)        /* truncate if necessary */
2742                 ret[length] = '\0';
2743         else if (length < 0) {
2744                 if (lr > offset - length) /* After we remove from the front and from the rear, is there anything left? */
2745                         ret[lr + length - offset] = '\0';
2746                 else
2747                         ret[0] = '\0';
2748         }
2749
2750         return ret;
2751 }
2752
2753 /*! \brief  Support for Asterisk built-in variables in the dialplan
2754
2755 \note   See also
2756         - \ref AstVar   Channel variables
2757         - \ref AstCauses The HANGUPCAUSE variable
2758  */
2759 void pbx_retrieve_variable(struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp)
2760 {
2761         const char not_found = '\0';
2762         char *tmpvar;
2763         const char *s;  /* the result */
2764         int offset, length;
2765         int i, need_substring;
2766         struct varshead *places[2] = { headp, &globals };       /* list of places where we may look */
2767
2768         if (c) {
2769                 ast_channel_lock(c);
2770                 places[0] = &c->varshead;
2771         }
2772         /*
2773          * Make a copy of var because parse_variable_name() modifies the string.
2774          * Then if called directly, we might need to run substring() on the result;
2775          * remember this for later in 'need_substring', 'offset' and 'length'
2776          */
2777         tmpvar = ast_strdupa(var);      /* parse_variable_name modifies the string */
2778         need_substring = parse_variable_name(tmpvar, &offset, &length, &i /* ignored */);
2779
2780         /*
2781          * Look first into predefined variables, then into variable lists.
2782          * Variable 's' points to the result, according to the following rules:
2783          * s == &not_found (set at the beginning) means that we did not find a
2784          *      matching variable and need to look into more places.
2785          * If s != &not_found, s is a valid result string as follows:
2786          * s = NULL if the variable does not have a value;
2787          *      you typically do this when looking for an unset predefined variable.
2788          * s = workspace if the result has been assembled there;
2789          *      typically done when the result is built e.g. with an snprintf(),
2790          *      so we don't need to do an additional copy.
2791          * s != workspace in case we have a string, that needs to be copied
2792          *      (the ast_copy_string is done once for all at the end).
2793          *      Typically done when the result is already available in some string.
2794          */
2795         s = &not_found; /* default value */
2796         if (c) {        /* This group requires a valid channel */
2797                 /* Names with common parts are looked up a piece at a time using strncmp. */
2798                 if (!strncmp(var, "CALL", 4)) {
2799                         if (!strncmp(var + 4, "ING", 3)) {
2800                                 if (!strcmp(var + 7, "PRES")) {                 /* CALLINGPRES */
2801                                         snprintf(workspace, workspacelen, "%d", c->cid.cid_pres);
2802                                         s = workspace;
2803                                 } else if (!strcmp(var + 7, "ANI2")) {          /* CALLINGANI2 */
2804                                         snprintf(workspace, workspacelen, "%d", c->cid.cid_ani2);
2805                                         s = workspace;
2806                                 } else if (!strcmp(var + 7, "TON")) {           /* CALLINGTON */
2807                                         snprintf(workspace, workspacelen, "%d", c->cid.cid_ton);
2808                                         s = workspace;
2809                                 } else if (!strcmp(var + 7, "TNS")) {           /* CALLINGTNS */
2810                                         snprintf(workspace, workspacelen, "%d", c->cid.cid_tns);
2811                                         s = workspace;
2812                                 }
2813                         }
2814                 } else if (!strcmp(var, "HINT")) {
2815                         s = ast_get_hint(workspace, workspacelen, NULL, 0, c, c->context, c->exten) ? workspace : NULL;
2816                 } else if (!strcmp(var, "HINTNAME")) {
2817                         s = ast_get_hint(NULL, 0, workspace, workspacelen, c, c->context, c->exten) ? workspace : NULL;
2818                 } else if (!strcmp(var, "EXTEN")) {
2819                         s = c->exten;
2820                 } else if (!strcmp(var, "CONTEXT")) {
2821                         s = c->context;
2822                 } else if (!strcmp(var, "PRIORITY")) {
2823                         snprintf(workspace, workspacelen, "%d", c->priority);
2824                         s = workspace;
2825                 } else if (!strcmp(var, "CHANNEL")) {
2826                         s = c->name;
2827                 } else if (!strcmp(var, "UNIQUEID")) {
2828                         s = c->uniqueid;
2829                 } else if (!strcmp(var, "HANGUPCAUSE")) {
2830                         snprintf(workspace, workspacelen, "%d", c->hangupcause);
2831                         s = workspace;
2832                 }
2833         }
2834         if (s == &not_found) { /* look for more */
2835                 if (!strcmp(var, "EPOCH")) {
2836                         snprintf(workspace, workspacelen, "%u",(int)time(NULL));
2837                         s = workspace;
2838                 } else if (!strcmp(var, "SYSTEMNAME")) {
2839                         s = ast_config_AST_SYSTEM_NAME;
2840                 } else if (!strcmp(var, "ENTITYID")) {
2841                         ast_eid_to_str(workspace, workspacelen, &g_eid);
2842                         s = workspace;
2843                 }
2844         }
2845         /* if not found, look into chanvars or global vars */
2846         for (i = 0; s == &not_found && i < ARRAY_LEN(places); i++) {
2847                 struct ast_var_t *variables;
2848                 if (!places[i])
2849                         continue;
2850                 if (places[i] == &globals)
2851                         ast_rwlock_rdlock(&globalslock);
2852                 AST_LIST_TRAVERSE(places[i], variables, entries) {
2853                         if (!strcasecmp(ast_var_name(variables), var)) {
2854                                 s = ast_var_value(variables);
2855                                 break;
2856                         }
2857                 }
2858                 if (places[i] == &globals)
2859                         ast_rwlock_unlock(&globalslock);
2860         }
2861         if (s == &not_found || s == NULL)
2862                 *ret = NULL;
2863         else {
2864                 if (s != workspace)
2865                         ast_copy_string(workspace, s, workspacelen);
2866                 *ret = workspace;
2867                 if (need_substring)
2868                         *ret = substring(*ret, offset, length, workspace, workspacelen);
2869         }
2870
2871         if (c)
2872                 ast_channel_unlock(c);
2873 }
2874
2875 static void exception_store_free(void *data)
2876 {
2877         struct pbx_exception *exception = data;
2878         ast_string_field_free_memory(exception);
2879         ast_free(exception);
2880 }
2881
2882 static struct ast_datastore_info exception_store_info = {
2883         .type = "EXCEPTION",
2884         .destroy = exception_store_free,
2885 };
2886
2887 int pbx_builtin_raise_exception(struct ast_channel *chan, void *vreason)
2888 {
2889         const char *reason = vreason;
2890         struct ast_datastore *ds = ast_channel_datastore_find(chan, &exception_store_info, NULL);
2891         struct pbx_exception *exception = NULL;
2892
2893         if (!ds)