Allow support for early media on AMI originates and call files.
[asterisk/asterisk.git] / include / asterisk / pbx.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, 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  * \brief Core PBX routines and definitions.
21  */
22
23 #ifndef _ASTERISK_PBX_H
24 #define _ASTERISK_PBX_H
25
26 #include "asterisk/channel.h"
27 #include "asterisk/sched.h"
28 #include "asterisk/devicestate.h"
29 #include "asterisk/presencestate.h"
30 #include "asterisk/chanvars.h"
31 #include "asterisk/hashtab.h"
32 #include "asterisk/stringfields.h"
33 #include "asterisk/xmldoc.h"
34 #include "asterisk/format.h"
35
36 #if defined(__cplusplus) || defined(c_plusplus)
37 extern "C" {
38 #endif
39
40 #define AST_MAX_APP     32      /*!< Max length of an application */
41
42 #define AST_PBX_GOTO_FAILED -3
43 #define AST_PBX_KEEP    0
44 #define AST_PBX_REPLACE 1
45
46 /*! \brief Special return values from applications to the PBX
47  * @{ */
48 #define AST_PBX_HANGUP                -1    /*!< Jump to the 'h' exten */
49 #define AST_PBX_OK                     0    /*!< No errors */
50 #define AST_PBX_ERROR                  1    /*!< Jump to the 'e' exten */
51 #define AST_PBX_INCOMPLETE             12   /*!< Return to PBX matching, allowing more digits for the extension */
52 /*! @} */
53
54 #define PRIORITY_HINT   -1      /*!< Special Priority for a hint */
55
56 /*!
57  * \brief Extension states
58  * \note States can be combined
59  * \ref AstExtState
60  */
61 enum ast_extension_states {
62         AST_EXTENSION_REMOVED = -2,     /*!< Extension removed */
63         AST_EXTENSION_DEACTIVATED = -1, /*!< Extension hint removed */
64         AST_EXTENSION_NOT_INUSE = 0,    /*!< No device INUSE or BUSY  */
65         AST_EXTENSION_INUSE = 1 << 0,   /*!< One or more devices INUSE */
66         AST_EXTENSION_BUSY = 1 << 1,    /*!< All devices BUSY */
67         AST_EXTENSION_UNAVAILABLE = 1 << 2, /*!< All devices UNAVAILABLE/UNREGISTERED */
68         AST_EXTENSION_RINGING = 1 << 3, /*!< All devices RINGING */
69         AST_EXTENSION_ONHOLD = 1 << 4,  /*!< All devices ONHOLD */
70 };
71
72
73 struct ast_context;
74 struct ast_exten;
75 struct ast_include;
76 struct ast_ignorepat;
77 struct ast_sw;
78  
79 enum ast_state_cb_update_reason {
80         /*! The extension state update is a result of a device state changing on the extension. */
81         AST_HINT_UPDATE_DEVICE = 1,
82         /*! The extension state update is a result of presence state changing on the extension. */
83         AST_HINT_UPDATE_PRESENCE = 2,
84 };
85
86 struct ast_state_cb_info {
87         enum ast_state_cb_update_reason reason;
88         enum ast_extension_states exten_state;
89         enum ast_presence_state presence_state;
90         const char *presence_subtype;
91         const char *presence_message;
92 };
93
94 /*! \brief Typedef for devicestate and hint callbacks */
95 typedef int (*ast_state_cb_type)(char *context, char *id, struct ast_state_cb_info *info, void *data);
96
97 /*! \brief Typedef for devicestate and hint callback removal indication callback */
98 typedef void (*ast_state_cb_destroy_type)(int id, void *data);
99
100 /*! \brief Data structure associated with a custom dialplan function */
101 struct ast_custom_function {
102         const char *name;                       /*!< Name */
103         AST_DECLARE_STRING_FIELDS(
104                 AST_STRING_FIELD(synopsis);     /*!< Synopsis text for 'show functions' */
105                 AST_STRING_FIELD(desc);         /*!< Description (help text) for 'show functions &lt;name&gt;' */
106                 AST_STRING_FIELD(syntax);       /*!< Syntax text for 'core show functions' */
107                 AST_STRING_FIELD(arguments);    /*!< Arguments description */
108                 AST_STRING_FIELD(seealso);      /*!< See also */
109         );
110         enum ast_doc_src docsrc;                /*!< Where the documentation come from */
111         /*! Read function, if read is supported */
112         ast_acf_read_fn_t read;         /*!< Read function, if read is supported */
113         /*! Read function, if read is supported.  Note: only one of read or read2
114          * needs to be implemented.  In new code, read2 should be implemented as
115          * the way forward, but they should return identical results, within the
116          * constraints of buffer size, if both are implemented.  That is, if the
117          * read function is handed a 16-byte buffer, and the result is 17 bytes
118          * long, then the first 15 bytes (remember NULL terminator) should be
119          * the same for both the read and the read2 methods. */
120         ast_acf_read2_fn_t read2;
121         /*! If no read2 function is provided, what maximum size? */
122         size_t read_max;
123         /*! Write function, if write is supported */
124         ast_acf_write_fn_t write;       /*!< Write function, if write is supported */
125         struct ast_module *mod;         /*!< Module this custom function belongs to */
126         AST_RWLIST_ENTRY(ast_custom_function) acflist;
127 };
128
129 /*! \brief All switch functions have the same interface, so define a type for them */
130 typedef int (ast_switch_f)(struct ast_channel *chan, const char *context,
131         const char *exten, int priority, const char *callerid, const char *data);
132
133 /*!< Data structure associated with an Asterisk switch */
134 struct ast_switch {
135         AST_LIST_ENTRY(ast_switch) list;
136         const char *name;                       /*!< Name of the switch */
137         const char *description;                /*!< Description of the switch */
138
139         ast_switch_f *exists;
140         ast_switch_f *canmatch;
141         ast_switch_f *exec;
142         ast_switch_f *matchmore;
143 };
144
145 struct ast_timing {
146         int hastime;                    /*!< If time construct exists */
147         unsigned int monthmask;         /*!< Mask for month */
148         unsigned int daymask;           /*!< Mask for date */
149         unsigned int dowmask;           /*!< Mask for day of week (sun-sat) */
150         unsigned int minmask[48];       /*!< Mask for minute */
151         char *timezone;                 /*!< NULL, or zoneinfo style timezone */
152 };
153
154 /*!
155  * \brief Construct a timing bitmap, for use in time-based conditionals.
156  * \param i Pointer to an ast_timing structure.
157  * \param info Standard string containing a timerange, weekday range, monthday range, and month range, as well as an optional timezone.
158  * \retval Returns 1 on success or 0 on failure.
159  */
160 int ast_build_timing(struct ast_timing *i, const char *info);
161
162 /*!
163  * \brief Evaluate a pre-constructed bitmap as to whether the current time falls within the range specified.
164  * \param i Pointer to an ast_timing structure.
165  * \retval Returns 1, if the time matches or 0, if the current time falls outside of the specified range.
166  */
167 int ast_check_timing(const struct ast_timing *i);
168
169 /*!
170  * \brief Evaluate a pre-constructed bitmap as to whether a particular time falls within the range specified.
171  * \param i Pointer to an ast_timing structure.
172  * \param tv Specified time
173  * \retval Returns 1, if the time matches or 0, if the time falls outside of the specified range.
174  */
175 int ast_check_timing2(const struct ast_timing *i, const struct timeval tv);
176
177 /*!
178  * \brief Deallocates memory structures associated with a timing bitmap.
179  * \param i Pointer to an ast_timing structure.
180  * \retval 0 success
181  * \retval non-zero failure (number suitable to pass to \see strerror)
182  */
183 int ast_destroy_timing(struct ast_timing *i);
184
185 struct ast_pbx {
186         int dtimeoutms;                         /*!< Timeout between digits (milliseconds) */
187         int rtimeoutms;                         /*!< Timeout for response (milliseconds) */
188 };
189
190
191 /*!
192  * \brief Register an alternative dialplan switch
193  *
194  * \param sw switch to register
195  *
196  * This function registers a populated ast_switch structure with the
197  * asterisk switching architecture.
198  *
199  * \retval 0 success
200  * \retval non-zero failure
201  */
202 int ast_register_switch(struct ast_switch *sw);
203
204 /*!
205  * \brief Unregister an alternative switch
206  *
207  * \param sw switch to unregister
208  *
209  * Unregisters a switch from asterisk.
210  *
211  * \return nothing
212  */
213 void ast_unregister_switch(struct ast_switch *sw);
214
215 /*!
216  * \brief Look up an application
217  *
218  * \param app name of the app
219  *
220  * This function searches for the ast_app structure within
221  * the apps that are registered for the one with the name
222  * you passed in.
223  *
224  * \return the ast_app structure that matches on success, or NULL on failure
225  */
226 struct ast_app *pbx_findapp(const char *app);
227
228 /*!
229  * \brief Execute an application
230  *
231  * \param c channel to execute on
232  * \param app which app to execute
233  * \param data the data passed into the app
234  *
235  * This application executes an application on a given channel.  It
236  * saves the stack and executes the given application passing in
237  * the given data.
238  *
239  * \retval 0 success
240  * \retval -1 failure
241  */
242 int pbx_exec(struct ast_channel *c, struct ast_app *app, const char *data);
243
244 /*!
245  * \brief Register a new context or find an existing one
246  *
247  * \param extcontexts pointer to the ast_context structure pointer
248  * \param exttable pointer to the hashtable that contains all the elements in extcontexts
249  * \param name name of the new context
250  * \param registrar registrar of the context
251  *
252  * This function allows you to play in two environments: the global contexts (active dialplan)
253  * or an external context set of your choosing. To act on the external set, make sure extcontexts
254  * and exttable are set; for the globals, make sure both extcontexts and exttable are NULL.
255  *
256  * This will first search for a context with your name.  If it exists already, it will not
257  * create a new one.  If it does not exist, it will create a new one with the given name
258  * and registrar.
259  *
260  * \return NULL on failure, and an ast_context structure on success
261  */
262 struct ast_context *ast_context_find_or_create(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *name, const char *registrar);
263
264 /*!
265  * \brief Merge the temporary contexts into a global contexts list and delete from the
266  *        global list the ones that are being added
267  *
268  * \param extcontexts pointer to the ast_context structure
269  * \param exttable pointer to the ast_hashtab structure that contains all the elements in extcontexts
270  * \param registrar of the context; if it's set the routine will delete all contexts
271  *        that belong to that registrar; if NULL only the contexts that are specified
272  *        in extcontexts
273  */
274 void ast_merge_contexts_and_delete(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *registrar);
275
276 /*!
277  * \brief Destroy a context (matches the specified context (or ANY context if NULL)
278  *
279  * \param con context to destroy
280  * \param registrar who registered it
281  *
282  * You can optionally leave out either parameter.  It will find it
283  * based on either the ast_context or the registrar name.
284  *
285  * \return nothing
286  */
287 void ast_context_destroy(struct ast_context *con, const char *registrar);
288
289 /*!
290  * \brief Find a context
291  *
292  * \param name name of the context to find
293  *
294  * Will search for the context with the given name.
295  *
296  * \return the ast_context on success, NULL on failure.
297  */
298 struct ast_context *ast_context_find(const char *name);
299
300 /*!
301  * \brief The result codes when starting the PBX on a channel with ast_pbx_start.
302  * \note AST_PBX_CALL_LIMIT refers to the maxcalls call limit in asterisk.conf
303  * \see ast_pbx_start
304  */
305 enum ast_pbx_result {
306         AST_PBX_SUCCESS = 0,
307         AST_PBX_FAILED = -1,
308         AST_PBX_CALL_LIMIT = -2,
309 };
310
311 /*!
312  * \brief Create a new thread and start the PBX
313  *
314  * \param c channel to start the pbx on
315  *
316  * \see ast_pbx_run for a synchronous function to run the PBX in the
317  * current thread, as opposed to starting a new one.
318  *
319  * \retval Zero on success
320  * \retval non-zero on failure
321  */
322 enum ast_pbx_result ast_pbx_start(struct ast_channel *c);
323
324 /*!
325  * \brief Execute the PBX in the current thread
326  *
327  * \param c channel to run the pbx on
328  *
329  * This executes the PBX on a given channel. It allocates a new
330  * PBX structure for the channel, and provides all PBX functionality.
331  * See ast_pbx_start for an asynchronous function to run the PBX in a
332  * new thread as opposed to the current one.
333  *
334  * \retval Zero on success
335  * \retval non-zero on failure
336  */
337 enum ast_pbx_result ast_pbx_run(struct ast_channel *c);
338
339 /*!
340  * \brief Options for ast_pbx_run()
341  */
342 struct ast_pbx_args {
343         union {
344                 /*! Pad this out so that we have plenty of room to add options
345                  *  but still maintain ABI compatibility over time. */
346                 uint64_t __padding;
347                 struct {
348                         /*! Do not hangup the channel when the PBX is complete. */
349                         unsigned int no_hangup_chan:1;
350                 };
351         };
352 };
353
354 /*!
355  * \brief Execute the PBX in the current thread
356  *
357  * \param c channel to run the pbx on
358  * \param args options for the pbx
359  *
360  * This executes the PBX on a given channel. It allocates a new
361  * PBX structure for the channel, and provides all PBX functionality.
362  * See ast_pbx_start for an asynchronous function to run the PBX in a
363  * new thread as opposed to the current one.
364  *
365  * \retval Zero on success
366  * \retval non-zero on failure
367  */
368 enum ast_pbx_result ast_pbx_run_args(struct ast_channel *c, struct ast_pbx_args *args);
369
370 /*!
371  * \brief Run the h exten from the given context.
372  * \since 11.0
373  *
374  * \param chan Channel to run the h exten on.
375  * \param context Context the h exten is in.
376  *
377  * \return Nothing
378  */
379 void ast_pbx_h_exten_run(struct ast_channel *chan, const char *context);
380
381 /*!
382  * \brief Run all hangup handlers on the channel.
383  * \since 11.0
384  *
385  * \param chan Channel to run the hangup handlers on.
386  *
387  * \note Absolutely _NO_ channel locks should be held before calling this function.
388  *
389  * \retval Zero if no hangup handlers run.
390  * \retval non-zero if hangup handlers were run.
391  */
392 int ast_pbx_hangup_handler_run(struct ast_channel *chan);
393
394 /*!
395  * \brief Init the hangup handler container on a channel.
396  * \since 11.0
397  *
398  * \param chan Channel to init the hangup handler container on.
399  *
400  * \return Nothing
401  */
402 void ast_pbx_hangup_handler_init(struct ast_channel *chan);
403
404 /*!
405  * \brief Destroy the hangup handler container on a channel.
406  * \since 11.0
407  *
408  * \param chan Channel to destroy the hangup handler container on.
409  *
410  * \return Nothing
411  */
412 void ast_pbx_hangup_handler_destroy(struct ast_channel *chan);
413
414 /*!
415  * \brief Pop the top of the channel hangup handler stack.
416  * \since 11.0
417  *
418  * \param chan Channel to push the hangup handler onto.
419  *
420  * \retval TRUE if a handler was popped off of the stack.
421  */
422 int ast_pbx_hangup_handler_pop(struct ast_channel *chan);
423
424 /*!
425  * \brief Push the given hangup handler onto the channel hangup handler stack.
426  * \since 11.0
427  *
428  * \param chan Channel to push the hangup handler onto.
429  * \param handler Gosub application parameter string.
430  *
431  * \return Nothing
432  */
433 void ast_pbx_hangup_handler_push(struct ast_channel *chan, const char *handler);
434
435 /*!
436  * \brief Add and extension to an extension context.
437  *
438  * \param context context to add the extension to
439  * \param replace
440  * \param extension extension to add
441  * \param priority priority level of extension addition
442  * \param label extension label
443  * \param callerid pattern to match CallerID, or NULL to match any CallerID
444  * \param application application to run on the extension with that priority level
445  * \param data data to pass to the application
446  * \param datad
447  * \param registrar who registered the extension
448  *
449  * \retval 0 success
450  * \retval -1 failure
451  */
452 int ast_add_extension(const char *context, int replace, const char *extension,
453         int priority, const char *label, const char *callerid,
454         const char *application, void *data, void (*datad)(void *), const char *registrar);
455
456 /*!
457  * \brief Add an extension to an extension context, this time with an ast_context *.
458  *
459  * \note For details about the arguments, check ast_add_extension()
460  */
461 int ast_add_extension2(struct ast_context *con, int replace, const char *extension,
462         int priority, const char *label, const char *callerid,
463         const char *application, void *data, void (*datad)(void *), const char *registrar);
464
465 /*!
466  * \brief Map devstate to an extension state.
467  *
468  * \param[in] devstate device state
469  *
470  * \return the extension state mapping.
471  */
472 enum ast_extension_states ast_devstate_to_extenstate(enum ast_device_state devstate);
473
474 /*!
475  * \brief Uses hint and devicestate callback to get the state of an extension
476  *
477  * \param c this is not important
478  * \param context which context to look in
479  * \param exten which extension to get state
480  *
481  * \return extension state as defined in the ast_extension_states enum
482  */
483 int ast_extension_state(struct ast_channel *c, const char *context, const char *exten);
484
485 /*!
486  * \brief Uses hint and presence state callback to get the presence state of an extension
487  *
488  * \param c this is not important
489  * \param context which context to look in
490  * \param exten which extension to get state
491  * \param[out] subtype Further information regarding the presence returned
492  * \param[out] message Custom message further describing current presence
493  *
494  * \note The subtype and message are dynamically allocated and must be freed by
495  * the caller of this function.
496  *
497  * \return returns the presence state value.
498  */
499 int ast_hint_presence_state(struct ast_channel *c, const char *context, const char *exten, char **subtype, char **message);
500
501 /*!
502  * \brief Return string representation of the state of an extension
503  *
504  * \param extension_state is the numerical state delivered by ast_extension_state
505  *
506  * \return the state of an extension as string
507  */
508 const char *ast_extension_state2str(int extension_state);
509
510 /*!
511  * \brief Registers a state change callback with destructor.
512  * \since 1.8.9
513  * \since 10.1.0
514  *
515  * \param context which context to look in
516  * \param exten which extension to get state
517  * \param change_cb callback to call if state changed
518  * \param destroy_cb callback to call when registration destroyed.
519  * \param data to pass to callback
520  *
521  * \note The change_cb is called if the state of an extension is changed.
522  *
523  * \note The destroy_cb is called when the registration is
524  * deleted so the registerer can release any associated
525  * resources.
526  *
527  * \retval -1 on failure
528  * \retval ID on success
529  */
530 int ast_extension_state_add_destroy(const char *context, const char *exten,
531         ast_state_cb_type change_cb, ast_state_cb_destroy_type destroy_cb, void *data);
532
533 /*!
534  * \brief Registers a state change callback
535  *
536  * \param context which context to look in
537  * \param exten which extension to get state
538  * \param change_cb callback to call if state changed
539  * \param data to pass to callback
540  *
541  * \note The change_cb is called if the state of an extension is changed.
542  *
543  * \retval -1 on failure
544  * \retval ID on success
545  */
546 int ast_extension_state_add(const char *context, const char *exten,
547         ast_state_cb_type change_cb, void *data);
548
549 /*!
550  * \brief Deletes a registered state change callback by ID
551  *
552  * \param id of the registered state callback to delete
553  * \param change_cb callback to call if state changed (Used if id == 0 (global))
554  *
555  * \retval 0 success
556  * \retval -1 failure
557  */
558 int ast_extension_state_del(int id, ast_state_cb_type change_cb);
559
560 /*!
561  * \brief If an extension hint exists, return non-zero
562  *
563  * \param hint buffer for hint
564  * \param hintsize size of hint buffer, in bytes
565  * \param name buffer for name portion of hint
566  * \param namesize size of name buffer
567  * \param c Channel from which to return the hint.  This is only important when the hint or name contains an expression to be expanded.
568  * \param context which context to look in
569  * \param exten which extension to search for
570  *
571  * \return If an extension within the given context with the priority PRIORITY_HINT
572  * is found, a non zero value will be returned.
573  * Otherwise, 0 is returned.
574  */
575 int ast_get_hint(char *hint, int hintsize, char *name, int namesize,
576         struct ast_channel *c, const char *context, const char *exten);
577
578 /*!
579  * \brief If an extension hint exists, return non-zero
580  *
581  * \param hint buffer for hint
582  * \param hintsize Maximum size of hint buffer (<0 to prevent growth, >0 to limit growth to that number of bytes, or 0 for unlimited growth)
583  * \param name buffer for name portion of hint
584  * \param namesize Maximum size of name buffer (<0 to prevent growth, >0 to limit growth to that number of bytes, or 0 for unlimited growth)
585  * \param c Channel from which to return the hint.  This is only important when the hint or name contains an expression to be expanded.
586  * \param context which context to look in
587  * \param exten which extension to search for
588  *
589  * \return If an extension within the given context with the priority PRIORITY_HINT
590  * is found, a non zero value will be returned.
591  * Otherwise, 0 is returned.
592  */
593 int ast_str_get_hint(struct ast_str **hint, ssize_t hintsize, struct ast_str **name, ssize_t namesize,
594         struct ast_channel *c, const char *context, const char *exten);
595
596 /*!
597  * \brief Determine whether an extension exists
598  *
599  * \param c this is not important
600  * \param context which context to look in
601  * \param exten which extension to search for
602  * \param priority priority of the action within the extension
603  * \param callerid callerid to search for
604  *
605  * \note It is possible for autoservice to be started and stopped on c during this
606  * function call, it is important that c is not locked prior to calling this. Otherwise
607  * a deadlock may occur
608  *
609  * \return If an extension within the given context(or callerid) with the given priority
610  *         is found a non zero value will be returned. Otherwise, 0 is returned.
611  */
612 int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten,
613         int priority, const char *callerid);
614
615 /*!
616  * \brief Find the priority of an extension that has the specified label
617  *
618  * \param c this is not important
619  * \param context which context to look in
620  * \param exten which extension to search for
621  * \param label label of the action within the extension to match to priority
622  * \param callerid callerid to search for
623  *
624  * \note It is possible for autoservice to be started and stopped on c during this
625  * function call, it is important that c is not locked prior to calling this. Otherwise
626  * a deadlock may occur
627  *
628  * \retval the priority which matches the given label in the extension
629  * \retval -1 if not found.
630  */
631 int ast_findlabel_extension(struct ast_channel *c, const char *context,
632         const char *exten, const char *label, const char *callerid);
633
634 /*!
635  * \brief Find the priority of an extension that has the specified label
636  *
637  * \note It is possible for autoservice to be started and stopped on c during this
638  * function call, it is important that c is not locked prior to calling this. Otherwise
639  * a deadlock may occur
640  *
641  * \note This function is the same as ast_findlabel_extension, except that it accepts
642  * a pointer to an ast_context structure to specify the context instead of the
643  * name of the context. Otherwise, the functions behave the same.
644  */
645 int ast_findlabel_extension2(struct ast_channel *c, struct ast_context *con,
646         const char *exten, const char *label, const char *callerid);
647
648 /*!
649  * \brief Looks for a valid matching extension
650  *
651  * \param c not really important
652  * \param context context to serach within
653  * \param exten extension to check
654  * \param priority priority of extension path
655  * \param callerid callerid of extension being searched for
656  *
657  * \note It is possible for autoservice to be started and stopped on c during this
658  * function call, it is important that c is not locked prior to calling this. Otherwise
659  * a deadlock may occur
660  *
661  * \return If "exten" *could be* a valid extension in this context with or without
662  * some more digits, return non-zero.  Basically, when this returns 0, no matter
663  * what you add to exten, it's not going to be a valid extension anymore
664  */
665 int ast_canmatch_extension(struct ast_channel *c, const char *context,
666         const char *exten, int priority, const char *callerid);
667
668 /*!
669  * \brief Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
670  *
671  * \param c not really important XXX
672  * \param context context to serach within
673  * \param exten extension to check
674  * \param priority priority of extension path
675  * \param callerid callerid of extension being searched for
676  *
677  * \note It is possible for autoservice to be started and stopped on c during this
678  * function call, it is important that c is not locked prior to calling this. Otherwise
679  * a deadlock may occur
680  *
681  * \return If "exten" *could match* a valid extension in this context with
682  * some more digits, return non-zero.  Does NOT return non-zero if this is
683  * an exact-match only.  Basically, when this returns 0, no matter
684  * what you add to exten, it's not going to be a valid extension anymore
685  */
686 int ast_matchmore_extension(struct ast_channel *c, const char *context,
687         const char *exten, int priority, const char *callerid);
688
689 /*!
690  * \brief Determine if a given extension matches a given pattern (in NXX format)
691  *
692  * \param pattern pattern to match
693  * \param extension extension to check against the pattern.
694  *
695  * Checks whether or not the given extension matches the given pattern.
696  *
697  * \retval 1 on match
698  * \retval 0 on failure
699  */
700 int ast_extension_match(const char *pattern, const char *extension);
701
702 int ast_extension_close(const char *pattern, const char *data, int needmore);
703
704 /*!
705  * \brief Determine if one extension should match before another
706  *
707  * \param a extension to compare with b
708  * \param b extension to compare with a
709  *
710  * Checks whether or extension a should match before extension b
711  *
712  * \retval 0 if the two extensions have equal matching priority
713  * \retval 1 on a > b
714  * \retval -1 on a < b
715  */
716 int ast_extension_cmp(const char *a, const char *b);
717
718 /*!
719  * \brief Launch a new extension (i.e. new stack)
720  *
721  * \param c not important
722  * \param context which context to generate the extension within
723  * \param exten new extension to add
724  * \param priority priority of new extension
725  * \param callerid callerid of extension
726  * \param found
727  * \param combined_find_spawn
728  *
729  * This adds a new extension to the asterisk extension list.
730  *
731  * \note It is possible for autoservice to be started and stopped on c during this
732  * function call, it is important that c is not locked prior to calling this. Otherwise
733  * a deadlock may occur
734  *
735  * \retval 0 on success
736  * \retval -1 on failure.
737  */
738 int ast_spawn_extension(struct ast_channel *c, const char *context,
739       const char *exten, int priority, const char *callerid, int *found, int combined_find_spawn);
740
741 /*!
742  * \brief Add a context include
743  *
744  * \param context context to add include to
745  * \param include new include to add
746  * \param registrar who's registering it
747  *
748  * Adds an include taking a char * string as the context parameter
749  *
750  * \retval 0 on success
751  * \retval -1 on error
752 */
753 int ast_context_add_include(const char *context, const char *include,
754         const char *registrar);
755
756 /*!
757  * \brief Add a context include
758  *
759  * \param con context to add the include to
760  * \param include include to add
761  * \param registrar who registered the context
762  *
763  * Adds an include taking a struct ast_context as the first parameter
764  *
765  * \retval 0 on success
766  * \retval -1 on failure
767  */
768 int ast_context_add_include2(struct ast_context *con, const char *include,
769         const char *registrar);
770
771 /*!
772  * \brief Remove a context include
773  *
774  * \note See ast_context_add_include for information on arguments
775  *
776  * \retval 0 on success
777  * \retval -1 on failure
778  */
779 int ast_context_remove_include(const char *context, const char *include,
780         const char *registrar);
781
782 /*!
783  * \brief Removes an include by an ast_context structure
784  *
785  * \note See ast_context_add_include2 for information on arguments
786  *
787  * \retval 0 on success
788  * \retval -1 on success
789  */
790 int ast_context_remove_include2(struct ast_context *con, const char *include,
791         const char *registrar);
792
793 /*!
794  * \brief Verifies includes in an ast_contect structure
795  *
796  * \param con context in which to verify the includes
797  *
798  * \retval 0 if no problems found
799  * \retval -1 if there were any missing context
800  */
801 int ast_context_verify_includes(struct ast_context *con);
802
803 /*!
804  * \brief Add a switch
805  *
806  * \param context context to which to add the switch
807  * \param sw switch to add
808  * \param data data to pass to switch
809  * \param eval whether to evaluate variables when running switch
810  * \param registrar whoever registered the switch
811  *
812  * This function registers a switch with the asterisk switch architecture
813  *
814  * \retval 0 on success
815  * \retval -1 on failure
816  */
817 int ast_context_add_switch(const char *context, const char *sw, const char *data,
818         int eval, const char *registrar);
819
820 /*!
821  * \brief Adds a switch (first param is a ast_context)
822  *
823  * \note See ast_context_add_switch() for argument information, with the exception of
824  *       the first argument. In this case, it's a pointer to an ast_context structure
825  *       as opposed to the name.
826  */
827 int ast_context_add_switch2(struct ast_context *con, const char *sw, const char *data,
828         int eval, const char *registrar);
829
830 /*!
831  * \brief Remove a switch
832  *
833  * Removes a switch with the given parameters
834  *
835  * \retval 0 on success
836  * \retval -1 on failure
837  */
838 int ast_context_remove_switch(const char *context, const char *sw,
839         const char *data, const char *registrar);
840
841 int ast_context_remove_switch2(struct ast_context *con, const char *sw,
842         const char *data, const char *registrar);
843
844 /*!
845  * \brief Simply remove extension from context
846  *
847  * \param context context to remove extension from
848  * \param extension which extension to remove
849  * \param priority priority of extension to remove (0 to remove all)
850  * \param registrar registrar of the extension
851  *
852  * This function removes an extension from a given context.
853  *
854  * \retval 0 on success
855  * \retval -1 on failure
856  *
857  * @{
858  */
859 int ast_context_remove_extension(const char *context, const char *extension, int priority,
860         const char *registrar);
861
862 int ast_context_remove_extension2(struct ast_context *con, const char *extension,
863         int priority, const char *registrar, int already_locked);
864
865 int ast_context_remove_extension_callerid(const char *context, const char *extension,
866         int priority, const char *callerid, int matchcid, const char *registrar);
867
868 int ast_context_remove_extension_callerid2(struct ast_context *con, const char *extension,
869         int priority, const char *callerid, int matchcid, const char *registrar,
870         int already_locked);
871 /*! @} */
872
873 /*!
874  * \brief Add an ignorepat
875  *
876  * \param context which context to add the ignorpattern to
877  * \param ignorepat ignorepattern to set up for the extension
878  * \param registrar registrar of the ignore pattern
879  *
880  * Adds an ignore pattern to a particular context.
881  *
882  * \retval 0 on success
883  * \retval -1 on failure
884  */
885 int ast_context_add_ignorepat(const char *context, const char *ignorepat, const char *registrar);
886
887 int ast_context_add_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
888
889 /*
890  * \brief Remove an ignorepat
891  *
892  * \param context context from which to remove the pattern
893  * \param ignorepat the pattern to remove
894  * \param registrar the registrar of the ignore pattern
895  *
896  * This removes the given ignorepattern
897  *
898  * \retval 0 on success
899  * \retval -1 on failure
900  */
901 int ast_context_remove_ignorepat(const char *context, const char *ignorepat, const char *registrar);
902
903 int ast_context_remove_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
904
905 /*!
906  * \brief Checks to see if a number should be ignored
907  *
908  * \param context context to search within
909  * \param pattern to check whether it should be ignored or not
910  *
911  * Check if a number should be ignored with respect to dialtone cancellation.
912  *
913  * \retval 0 if the pattern should not be ignored
914  * \retval non-zero if the pattern should be ignored
915  */
916 int ast_ignore_pattern(const char *context, const char *pattern);
917
918 /* Locking functions for outer modules, especially for completion functions */
919
920 /*!
921  * \brief Write locks the context list
922  *
923  * \retval 0 on success
924  * \retval -1 on error
925  */
926 int ast_wrlock_contexts(void);
927
928 /*!
929  * \brief Read locks the context list
930  *
931  * \retval 0 on success
932  * \retval -1 on error
933  */
934 int ast_rdlock_contexts(void);
935
936 /*!
937  * \brief Unlocks contexts
938  *
939  * \retval 0 on success
940  * \retval -1 on failure
941  */
942 int ast_unlock_contexts(void);
943
944 /*!
945  * \brief Write locks a given context
946  *
947  * \param con context to lock
948  *
949  * \retval 0 on success
950  * \retval -1 on failure
951  */
952 int ast_wrlock_context(struct ast_context *con);
953
954 /*!
955  * \brief Read locks a given context
956  *
957  * \param con context to lock
958  *
959  * \retval 0 on success
960  * \retval -1 on failure
961  */
962 int ast_rdlock_context(struct ast_context *con);
963
964 /*!
965  * \retval Unlocks the given context
966  *
967  * \param con context to unlock
968  *
969  * \retval 0 on success
970  * \retval -1 on failure
971  */
972 int ast_unlock_context(struct ast_context *con);
973
974 /*!
975  * \brief locks the macrolock in the given given context
976  *
977  * \param macrocontext name of the macro-context to lock
978  *
979  * Locks the given macro-context to ensure only one thread (call) can execute it at a time
980  *
981  * \retval 0 on success
982  * \retval -1 on failure
983  */
984 int ast_context_lockmacro(const char *macrocontext);
985
986 /*!
987  * \brief Unlocks the macrolock in the given context
988  *
989  * \param macrocontext name of the macro-context to unlock
990  *
991  * Unlocks the given macro-context so that another thread (call) can execute it
992  *
993  * \retval 0 on success
994  * \retval -1 on failure
995  */
996 int ast_context_unlockmacro(const char *macrocontext);
997
998 /*!
999  * \brief Set the channel to next execute the specified dialplan location.
1000  * \see ast_async_parseable_goto, ast_async_goto_if_exists
1001  *
1002  * \note Do _NOT_ hold any channel locks when calling this function.
1003  */
1004 int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
1005
1006 /*!
1007  * \brief Set the channel to next execute the specified dialplan location.
1008  */
1009 int ast_async_goto_by_name(const char *chan, const char *context, const char *exten, int priority);
1010
1011 /*! Synchronously or asynchronously make an outbound call and send it to a
1012    particular extension */
1013 int ast_pbx_outgoing_exten(const char *type, struct ast_format_cap *cap, const char *addr, int timeout, const char *context, const char *exten, int priority, int *reason, int sync, const char *cid_num, const char *cid_name, struct ast_variable *vars, const char *account, struct ast_channel **locked_channel, int early_media);
1014
1015 /*! Synchronously or asynchronously make an outbound call and send it to a
1016    particular application with given extension */
1017 int ast_pbx_outgoing_app(const char *type, struct ast_format_cap *cap, const char *addr, int timeout, const char *app, const char *appdata, int *reason, int sync, const char *cid_num, const char *cid_name, struct ast_variable *vars, const char *account, struct ast_channel **locked_channel);
1018
1019 /*!
1020  * \brief Evaluate a condition
1021  *
1022  * \retval 0 if the condition is NULL or of zero length
1023  * \retval int If the string is an integer, the integer representation of
1024  *             the integer is returned
1025  * \retval 1 Any other non-empty string
1026  */
1027 int pbx_checkcondition(const char *condition);
1028
1029 /*! @name
1030  * Functions for returning values from structures */
1031 /*! @{ */
1032 const char *ast_get_context_name(struct ast_context *con);
1033 const char *ast_get_extension_name(struct ast_exten *exten);
1034 struct ast_context *ast_get_extension_context(struct ast_exten *exten);
1035 const char *ast_get_include_name(struct ast_include *include);
1036 const char *ast_get_ignorepat_name(struct ast_ignorepat *ip);
1037 const char *ast_get_switch_name(struct ast_sw *sw);
1038 const char *ast_get_switch_data(struct ast_sw *sw);
1039 int ast_get_switch_eval(struct ast_sw *sw);
1040
1041 /*! @} */
1042
1043 /*! @name Other Extension stuff */
1044 /*! @{ */
1045 int ast_get_extension_priority(struct ast_exten *exten);
1046 int ast_get_extension_matchcid(struct ast_exten *e);
1047 const char *ast_get_extension_cidmatch(struct ast_exten *e);
1048 const char *ast_get_extension_app(struct ast_exten *e);
1049 const char *ast_get_extension_label(struct ast_exten *e);
1050 void *ast_get_extension_app_data(struct ast_exten *e);
1051 /*! @} */
1052
1053 /*! @name Registrar info functions ... */
1054 /*! @{ */
1055 const char *ast_get_context_registrar(struct ast_context *c);
1056 const char *ast_get_extension_registrar(struct ast_exten *e);
1057 const char *ast_get_include_registrar(struct ast_include *i);
1058 const char *ast_get_ignorepat_registrar(struct ast_ignorepat *ip);
1059 const char *ast_get_switch_registrar(struct ast_sw *sw);
1060 /*! @} */
1061
1062 /*! @name Walking functions ... */
1063 /*! @{ */
1064 struct ast_context *ast_walk_contexts(struct ast_context *con);
1065 struct ast_exten *ast_walk_context_extensions(struct ast_context *con,
1066         struct ast_exten *priority);
1067 struct ast_exten *ast_walk_extension_priorities(struct ast_exten *exten,
1068         struct ast_exten *priority);
1069 struct ast_include *ast_walk_context_includes(struct ast_context *con,
1070         struct ast_include *inc);
1071 struct ast_ignorepat *ast_walk_context_ignorepats(struct ast_context *con,
1072         struct ast_ignorepat *ip);
1073 struct ast_sw *ast_walk_context_switches(struct ast_context *con, struct ast_sw *sw);
1074 /*! @} */
1075
1076 /*!
1077  * \brief Create a human-readable string, specifying all variables and their corresponding values.
1078  * \param chan Channel from which to read variables
1079  * \param buf Dynamic string in which to place the result (should be allocated with ast_str_create).
1080  * \see ast_str_create
1081  * \note Will lock the channel.
1082  */
1083 int pbx_builtin_serialize_variables(struct ast_channel *chan, struct ast_str **buf);
1084
1085 /*!
1086  * \brief Return a pointer to the value of the corresponding channel variable.
1087  * \note Will lock the channel.
1088  *
1089  * \note This function will return a pointer to the buffer inside the channel
1090  * variable.  This value should only be accessed with the channel locked.  If
1091  * the value needs to be kept around, it should be done by using the following
1092  * thread-safe code:
1093  * \code
1094  *              const char *var;
1095  *
1096  *              ast_channel_lock(chan);
1097  *              if ((var = pbx_builtin_getvar_helper(chan, "MYVAR"))) {
1098  *                      var = ast_strdupa(var);
1099  *              }
1100  *              ast_channel_unlock(chan);
1101  * \endcode
1102  */
1103 const char *pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name);
1104
1105 /*!
1106  * \brief Add a variable to the channel variable stack, without removing any previously set value.
1107  * \note Will lock the channel.
1108  */
1109 void pbx_builtin_pushvar_helper(struct ast_channel *chan, const char *name, const char *value);
1110
1111 /*!
1112  * \brief Add a variable to the channel variable stack, removing the most recently set value for the same name.
1113  * \note Will lock the channel.  May also be used to set a channel dialplan function to a particular value.
1114  * \see ast_func_write
1115  * \return -1 if the dialplan function fails to be set
1116  * \version 1.8 changed the function to return an error code
1117  */
1118 int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value);
1119
1120 /*!
1121  * \brief Retrieve the value of a builtin variable or variable from the channel variable stack.
1122  * \note Will lock the channel.
1123  */
1124 void pbx_retrieve_variable(struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp);
1125 void pbx_builtin_clear_globals(void);
1126
1127 /*!
1128  * \brief Parse and set a single channel variable, where the name and value are separated with an '=' character.
1129  * \note Will lock the channel.
1130  */
1131 int pbx_builtin_setvar(struct ast_channel *chan, const char *data);
1132
1133 /*!
1134  * \brief Parse and set multiple channel variables, where the pairs are separated by the ',' character, and name and value are separated with an '=' character.
1135  * \note Will lock the channel.
1136  */
1137 int pbx_builtin_setvar_multiple(struct ast_channel *chan, const char *data);
1138
1139 int pbx_builtin_raise_exception(struct ast_channel *chan, const char *data);
1140
1141 /*! @name Substitution routines, using static string buffers
1142  * @{ */
1143 void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count);
1144 void pbx_substitute_variables_varshead(struct varshead *headp, const char *cp1, char *cp2, int count);
1145 void pbx_substitute_variables_helper_full(struct ast_channel *c, struct varshead *headp, const char *cp1, char *cp2, int cp2_size, size_t *used);
1146 /*! @} */
1147 /*! @} */
1148
1149 /*! @name Substitution routines, using dynamic string buffers */
1150
1151 /*!
1152  * \param buf Result will be placed in this buffer.
1153  * \param maxlen -1 if the buffer should not grow, 0 if the buffer may grow to any size, and >0 if the buffer should grow only to that number of bytes.
1154  * \param chan Channel variables from which to extract values, and channel to pass to any dialplan functions.
1155  * \param headp If no channel is specified, a channel list from which to extract variable values
1156  * \param var Variable name to retrieve.
1157  */
1158 const char *ast_str_retrieve_variable(struct ast_str **buf, ssize_t maxlen, struct ast_channel *chan, struct varshead *headp, const char *var);
1159
1160 /*!
1161  * \param buf Result will be placed in this buffer.
1162  * \param maxlen -1 if the buffer should not grow, 0 if the buffer may grow to any size, and >0 if the buffer should grow only to that number of bytes.
1163  * \param chan Channel variables from which to extract values, and channel to pass to any dialplan functions.
1164  * \param templ Variable template to expand.
1165  */
1166 void ast_str_substitute_variables(struct ast_str **buf, ssize_t maxlen, struct ast_channel *chan, const char *templ);
1167
1168 /*!
1169  * \param buf Result will be placed in this buffer.
1170  * \param maxlen -1 if the buffer should not grow, 0 if the buffer may grow to any size, and >0 if the buffer should grow only to that number of bytes.
1171  * \param headp If no channel is specified, a channel list from which to extract variable values
1172  * \param templ Variable template to expand.
1173  */
1174 void ast_str_substitute_variables_varshead(struct ast_str **buf, ssize_t maxlen, struct varshead *headp, const char *templ);
1175
1176 /*!
1177  * \param buf Result will be placed in this buffer.
1178  * \param maxlen -1 if the buffer should not grow, 0 if the buffer may grow to any size, and >0 if the buffer should grow only to that number of bytes.
1179  * \param c Channel variables from which to extract values, and channel to pass to any dialplan functions.
1180  * \param headp If no channel is specified, a channel list from which to extract variable values
1181  * \param templ Variable template to expand.
1182  * \param used Number of bytes read from the template.
1183  */
1184 void ast_str_substitute_variables_full(struct ast_str **buf, ssize_t maxlen, struct ast_channel *c, struct varshead *headp, const char *templ, size_t *used);
1185 /*! @} */
1186
1187 int ast_extension_patmatch(const char *pattern, const char *data);
1188
1189 /*! Set "autofallthrough" flag, if newval is <0, does not actually set.  If
1190   set to 1, sets to auto fall through.  If newval set to 0, sets to no auto
1191   fall through (reads extension instead).  Returns previous value. */
1192 int pbx_set_autofallthrough(int newval);
1193
1194 /*! Set "extenpatternmatchnew" flag, if newval is <0, does not actually set.  If
1195   set to 1, sets to use the new Trie-based pattern matcher.  If newval set to 0, sets to use
1196   the old linear-search algorithm.  Returns previous value. */
1197 int pbx_set_extenpatternmatchnew(int newval);
1198
1199 /*! Set "overrideswitch" field.  If set and of nonzero length, all contexts
1200  * will be tried directly through the named switch prior to any other
1201  * matching within that context.
1202  * \since 1.6.1
1203  */
1204 void pbx_set_overrideswitch(const char *newval);
1205
1206 /*!
1207  * \note This function will handle locking the channel as needed.
1208  */
1209 int ast_goto_if_exists(struct ast_channel *chan, const char *context, const char *exten, int priority);
1210
1211 /*!
1212  * \note This function will handle locking the channel as needed.
1213  */
1214 int ast_parseable_goto(struct ast_channel *chan, const char *goto_string);
1215
1216 /*!
1217  * \note This function will handle locking the channel as needed.
1218  */
1219 int ast_async_parseable_goto(struct ast_channel *chan, const char *goto_string);
1220
1221 /*!
1222  * \note This function will handle locking the channel as needed.
1223  */
1224 int ast_explicit_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
1225
1226 /*!
1227  * \note This function will handle locking the channel as needed.
1228  */
1229 int ast_async_goto_if_exists(struct ast_channel *chan, const char *context, const char *exten, int priority);
1230
1231 struct ast_custom_function* ast_custom_function_find(const char *name);
1232
1233 /*!
1234  * \brief Unregister a custom function
1235  */
1236 int ast_custom_function_unregister(struct ast_custom_function *acf);
1237
1238 /*!
1239  * \brief Register a custom function
1240  */
1241 #define ast_custom_function_register(acf) __ast_custom_function_register(acf, ast_module_info->self)
1242
1243 /*!
1244  * \brief Register a custom function
1245  */
1246 int __ast_custom_function_register(struct ast_custom_function *acf, struct ast_module *mod);
1247
1248 /*!
1249  * \brief Retrieve the number of active calls
1250  */
1251 int ast_active_calls(void);
1252
1253 /*!
1254  * \brief Retrieve the total number of calls processed through the PBX since last restart
1255  */
1256 int ast_processed_calls(void);
1257
1258 /*!
1259  * \brief executes a read operation on a function
1260  *
1261  * \param chan Channel to execute on
1262  * \param function Data containing the function call string (will be modified)
1263  * \param workspace A pointer to safe memory to use for a return value
1264  * \param len the number of bytes in workspace
1265  *
1266  * This application executes a function in read mode on a given channel.
1267  *
1268  * \retval 0 success
1269  * \retval non-zero failure
1270  */
1271 int ast_func_read(struct ast_channel *chan, const char *function, char *workspace, size_t len);
1272
1273 /*!
1274  * \brief executes a read operation on a function
1275  *
1276  * \param chan Channel to execute on
1277  * \param function Data containing the function call string (will be modified)
1278  * \param str A dynamic string buffer into which to place the result.
1279  * \param maxlen <0 if the dynamic buffer should not grow; >0 if the dynamic buffer should be limited to that number of bytes; 0 if the dynamic buffer has no upper limit
1280  *
1281  * This application executes a function in read mode on a given channel.
1282  *
1283  * \retval 0 success
1284  * \retval non-zero failure
1285  */
1286 int ast_func_read2(struct ast_channel *chan, const char *function, struct ast_str **str, ssize_t maxlen);
1287
1288 /*!
1289  * \brief executes a write operation on a function
1290  *
1291  * \param chan Channel to execute on
1292  * \param function Data containing the function call string (will be modified)
1293  * \param value A value parameter to pass for writing
1294  *
1295  * This application executes a function in write mode on a given channel.
1296  *
1297  * \retval 0 success
1298  * \retval non-zero failure
1299  */
1300 int ast_func_write(struct ast_channel *chan, const char *function, const char *value);
1301
1302 /*!
1303  * \details
1304  * When looking up extensions, we can have different requests
1305  * identified by the 'action' argument, as follows.
1306  *
1307  * \note that the coding is such that the low 4 bits are the
1308  * third argument to extension_match_core.
1309  */
1310 enum ext_match_t {
1311         E_MATCHMORE =   0x00,   /* extension can match but only with more 'digits' */
1312         E_CANMATCH =    0x01,   /* extension can match with or without more 'digits' */
1313         E_MATCH =       0x02,   /* extension is an exact match */
1314         E_MATCH_MASK =  0x03,   /* mask for the argument to extension_match_core() */
1315         E_SPAWN =       0x12,   /* want to spawn an extension. Requires exact match */
1316         E_FINDLABEL =   0x22    /* returns the priority for a given label. Requires exact match */
1317 };
1318
1319 #define STATUS_NO_CONTEXT       1
1320 #define STATUS_NO_EXTENSION     2
1321 #define STATUS_NO_PRIORITY      3
1322 #define STATUS_NO_LABEL         4
1323 #define STATUS_SUCCESS          5
1324 #define AST_PBX_MAX_STACK  128
1325
1326 /* request and result for pbx_find_extension */
1327 struct pbx_find_info {
1328 #if 0
1329         const char *context;
1330         const char *exten;
1331         int priority;
1332 #endif
1333
1334         char *incstack[AST_PBX_MAX_STACK];      /* filled during the search */
1335         int stacklen;                   /* modified during the search */
1336         int status;                     /* set on return */
1337         struct ast_switch *swo;         /* set on return */
1338         const char *data;               /* set on return */
1339         const char *foundcontext;       /* set on return */
1340 };
1341
1342 struct ast_exten *pbx_find_extension(struct ast_channel *chan,
1343                                                                          struct ast_context *bypass, struct pbx_find_info *q,
1344                                                                          const char *context, const char *exten, int priority,
1345                                                                          const char *label, const char *callerid, enum ext_match_t action);
1346
1347 /*! \brief hashtable functions for contexts */
1348 /*! @{ */
1349 int ast_hashtab_compare_contexts(const void *ah_a, const void *ah_b);
1350 unsigned int ast_hashtab_hash_contexts(const void *obj);
1351 /*! @} */
1352
1353 /*!
1354  * \brief Command completion for the list of installed applications.
1355  *
1356  * This can be called from a CLI command completion function that wants to
1357  * complete from the list of available applications.
1358  */
1359 char *ast_complete_applications(const char *line, const char *word, int state);
1360
1361 #if defined(__cplusplus) || defined(c_plusplus)
1362 }
1363 #endif
1364
1365 #endif /* _ASTERISK_PBX_H */