constify a couple of function arguments
[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/sched.h"
27 #include "asterisk/channel.h"
28
29 #if defined(__cplusplus) || defined(c_plusplus)
30 extern "C" {
31 #endif
32
33 #define AST_PBX_KEEP    0
34 #define AST_PBX_REPLACE 1
35
36 #define AST_MAX_APP     32      /*!< Max length of an application */
37
38 /*! \brief Special return values from applications to the PBX { */
39 #define AST_PBX_KEEPALIVE       10      /*!< Destroy the thread, but don't hang up the channel */
40 #define AST_PBX_NO_HANGUP_PEER  11
41 /*! } */
42
43 #define PRIORITY_HINT   -1      /*!< Special Priority for a hint */
44
45 /*! \brief Extension states */
46 enum ast_extension_states {
47         AST_EXTENSION_REMOVED = -2,     /*!< Extension removed */
48         AST_EXTENSION_DEACTIVATED = -1, /*!< Extension hint removed */
49         AST_EXTENSION_NOT_INUSE = 0,    /*!< No device INUSE or BUSY  */
50         AST_EXTENSION_INUSE = 1 << 0,   /*!< One or more devices INUSE */
51         AST_EXTENSION_BUSY = 1 << 1,    /*!< All devices BUSY */
52         AST_EXTENSION_UNAVAILABLE = 1 << 2, /*!< All devices UNAVAILABLE/UNREGISTERED */
53         AST_EXTENSION_RINGING = 1 << 3, /*!< All devices RINGING */
54 };
55
56
57 struct ast_context;
58 struct ast_exten;     
59 struct ast_include;
60 struct ast_ignorepat;
61 struct ast_sw;
62
63 /*! \brief Typedef for devicestate and hint callbacks */
64 typedef int (*ast_state_cb_type)(char *context, char* id, enum ast_extension_states state, void *data);
65
66 /*! \brief Data structure associated with a custom dialplan function */
67 struct ast_custom_function {
68         const char *name;               /*!< Name */
69         const char *synopsis;           /*!< Short description for "show functions" */
70         const char *desc;               /*!< Help text that explains it all */
71         const char *syntax;             /*!< Syntax description */
72         int (*read)(struct ast_channel *, char *, char *, char *, size_t);      /*!< Read function, if read is supported */
73         int (*write)(struct ast_channel *, char *, char *, const char *);       /*!< Write function, if write is supported */
74         struct ast_custom_function *next;
75 };
76
77 /*! \brief All switch functions have the same interface, so define a type for them */
78 typedef int (ast_switch_f)(struct ast_channel *chan, const char *context,
79         const char *exten, int priority, const char *callerid, const char *data);
80
81 /*!< Data structure associated with an Asterisk switch */
82 struct ast_switch {
83         struct ast_switch *next;        
84         const char *name;                       /*!< Name of the switch */
85         const char *description;                /*!< Description of the switch */
86         
87         ast_switch_f *exists;
88         ast_switch_f *canmatch;
89         ast_switch_f *exec;
90         ast_switch_f *matchmore;
91 };
92
93 struct ast_timing {
94         int hastime;                            /*!< If time construct exists */
95         unsigned int monthmask;                 /*!< Mask for month */
96         unsigned int daymask;                   /*!< Mask for date */
97         unsigned int dowmask;                   /*!< Mask for day of week (mon-sun) */
98         unsigned int minmask[24];               /*!< Mask for minute */
99 };
100
101 int ast_build_timing(struct ast_timing *i, const char *info);
102 int ast_check_timing(const struct ast_timing *i);
103
104 struct ast_pbx {
105         int dtimeout;                           /*!< Timeout between digits (seconds) */
106         int rtimeout;                           /*!< Timeout for response (seconds) */
107 };
108
109
110 /*!
111  * \brief Register an alternative dialplan switch
112  *
113  * \param sw switch to register
114  *
115  * This function registers a populated ast_switch structure with the
116  * asterisk switching architecture.
117  *
118  * \return 0 on success, and other than 0 on failure
119  */
120 int ast_register_switch(struct ast_switch *sw);
121
122 /*!
123  * \brief Unregister an alternative switch
124  *
125  * \param sw switch to unregister
126  * 
127  * Unregisters a switch from asterisk.
128  *
129  * \return nothing
130  */
131 void ast_unregister_switch(struct ast_switch *sw);
132
133 /*!
134  * \brief Look up an application
135  *
136  * \param app name of the app
137  *
138  * This function searches for the ast_app structure within
139  * the apps that are registered for the one with the name
140  * you passed in.
141  *
142  * \return the ast_app structure that matches on success, or NULL on failure
143  */
144 struct ast_app *pbx_findapp(const char *app);
145
146 /*!
147  * \brief Execute an application
148  *
149  * \param c channel to execute on
150  * \param app which app to execute
151  * \param data the data passed into the app
152  *
153  * This application executes an application on a given channel.  It
154  * saves the stack and executes the given appliation passing in
155  * the given data.
156  *
157  * \return 0 on success, and -1 on failure
158  */
159 int pbx_exec(struct ast_channel *c, struct ast_app *app, void *data);
160
161 /*!
162  * \brief Register a new context
163  *
164  * \param extcontexts pointer to the ast_context structure pointer
165  * \param name name of the new context
166  * \param registrar registrar of the context
167  *
168  * This will first search for a context with your name.  If it exists already, it will not
169  * create a new one.  If it does not exist, it will create a new one with the given name
170  * and registrar.
171  *
172  * \return NULL on failure, and an ast_context structure on success
173  */
174 struct ast_context *ast_context_create(struct ast_context **extcontexts, const char *name, const char *registrar);
175
176 /*!
177  * \brief Merge the temporary contexts into a global contexts list and delete from the 
178  *        global list the ones that are being added
179  *
180  * \param extcontexts pointer to the ast_context structure pointer
181  * \param registrar of the context; if it's set the routine will delete all contexts 
182  *        that belong to that registrar; if NULL only the contexts that are specified 
183  *        in extcontexts
184  */
185 void ast_merge_contexts_and_delete(struct ast_context **extcontexts, const char *registrar);
186
187 /*!
188  * \brief Destroy a context (matches the specified context (or ANY context if NULL)
189  *
190  * \param con context to destroy
191  * \param registrar who registered it
192  *
193  * You can optionally leave out either parameter.  It will find it
194  * based on either the ast_context or the registrar name.
195  *
196  * \return nothing
197  */
198 void ast_context_destroy(struct ast_context *con, const char *registrar);
199
200 /*!
201  * \brief Find a context
202  *
203  * \param name name of the context to find
204  *
205  * Will search for the context with the given name.
206  *
207  * \return the ast_context on success, NULL on failure.
208  */
209 struct ast_context *ast_context_find(const char *name);
210
211 enum ast_pbx_result {
212         AST_PBX_SUCCESS = 0,
213         AST_PBX_FAILED = -1,
214         AST_PBX_CALL_LIMIT = -2,
215 };
216
217 /*!
218  * \brief Create a new thread and start the PBX
219  *
220  * \param c channel to start the pbx on
221  *
222  * See ast_pbx_run for a synchronous function to run the PBX in the
223  * current thread, as opposed to starting a new one.
224  *
225  * \return Zero on success, non-zero on failure
226  */
227 enum ast_pbx_result ast_pbx_start(struct ast_channel *c);
228
229 /*!
230  * \brief Execute the PBX in the current thread
231  *
232  * \param c channel to run the pbx on
233  *
234  * This executes the PBX on a given channel. It allocates a new
235  * PBX structure for the channel, and provides all PBX functionality.
236  * See ast_pbx_start for an asynchronous function to run the PBX in a
237  * new thread as opposed to the current one.
238  * 
239  * \return Zero on success, non-zero on failure
240  */
241 enum ast_pbx_result ast_pbx_run(struct ast_channel *c);
242
243 /*! 
244  * \brief Add and extension to an extension context.  
245  * 
246  * \param context context to add the extension to
247  * \param replace
248  * \param extension extension to add
249  * \param priority priority level of extension addition
250  * \param label extension label
251  * \param callerid pattern to match CallerID, or NULL to match any CallerID
252  * \param application application to run on the extension with that priority level
253  * \param data data to pass to the application
254  * \param datad
255  * \param registrar who registered the extension
256  *
257  * \retval 0 success 
258  * \retval -1 failure
259  */
260 int ast_add_extension(const char *context, int replace, const char *extension, 
261         int priority, const char *label, const char *callerid,
262         const char *application, void *data, void (*datad)(void *), const char *registrar);
263
264 /*! 
265  * \brief Add an extension to an extension context, this time with an ast_context *.
266  *
267  * \note For details about the arguments, check ast_add_extension()
268  */
269 int ast_add_extension2(struct ast_context *con, int replace, const char *extension,
270         int priority, const char *label, const char *callerid, 
271         const char *application, void *data, void (*datad)(void *), const char *registrar);
272
273
274 /*! 
275  * \brief Register an application.
276  *
277  * \param app Short name of the application
278  * \param execute a function callback to execute the application. It should return
279  *                non-zero if the channel needs to be hung up.
280  * \param synopsis a short description (one line synopsis) of the application
281  * \param description long description with all of the details about the use of 
282  *                    the application
283  * 
284  * This registers an application with Asterisk's internal application list. 
285  * \note The individual applications themselves are responsible for registering and unregistering
286  *       and unregistering their own CLI commands.
287  * 
288  * \retval 0 success 
289  * \retval -1 failure.
290  */
291 int ast_register_application(const char *app, int (*execute)(struct ast_channel *, void *),
292                              const char *synopsis, const char *description);
293
294 /*! 
295  * \brief Unregister an application
296  * 
297  * \param app name of the application (does not have to be the same string as the one that was registered)
298  * 
299  * This unregisters an application from Asterisk's internal application list.
300  * 
301  * \retval 0 success 
302  * \retval -1 failure
303  */
304 int ast_unregister_application(const char *app);
305
306 /*! 
307  * \brief Uses hint and devicestate callback to get the state of an extension
308  *
309  * \param c this is not important
310  * \param context which context to look in
311  * \param exten which extension to get state
312  *
313  * \return extension state as defined in the ast_extension_states enum
314  */
315 int ast_extension_state(struct ast_channel *c, const char *context, const char *exten);
316
317 /*! 
318  * \brief Return string representation of the state of an extension
319  * 
320  * \param extension_state is the numerical state delivered by ast_extension_state
321  *
322  * \return the state of an extension as string
323  */
324 const char *ast_extension_state2str(int extension_state);
325
326 /*!
327  * \brief Registers a state change callback
328  * 
329  * \param context which context to look in
330  * \param exten which extension to get state
331  * \param callback callback to call if state changed
332  * \param data to pass to callback
333  *
334  * The callback is called if the state of an extension is changed.
335  *
336  * \retval -1 on failure
337  * \retval ID on success
338  */ 
339 int ast_extension_state_add(const char *context, const char *exten, 
340                             ast_state_cb_type callback, void *data);
341
342 /*! 
343  * \brief Deletes a registered state change callback by ID
344  * 
345  * \param id of the callback to delete
346  * \param callback callback
347  *
348  * Removes the callback from list of callbacks
349  *
350  * \retval 0 success 
351  * \retval -1 failure
352  */
353 int ast_extension_state_del(int id, ast_state_cb_type callback);
354
355 /*! 
356  * \brief If an extension exists, return non-zero
357  * 
358  * \param hint buffer for hint
359  * \param maxlen size of hint buffer
360  * \param name buffer for name portion of hint
361  * \param maxnamelen size of name buffer
362  * \param c this is not important
363  * \param context which context to look in
364  * \param exten which extension to search for
365  *
366  * \return If an extension within the given context with the priority PRIORITY_HINT
367  * is found a non zero value will be returned.
368  * Otherwise, 0 is returned.
369  */
370 int ast_get_hint(char *hint, int maxlen, char *name, int maxnamelen, 
371         struct ast_channel *c, const char *context, const char *exten);
372
373 /*!
374  * \brief Determine whether an extension exists
375  *
376  * \param c this is not important
377  * \param context which context to look in
378  * \param exten which extension to search for
379  * \param priority priority of the action within the extension
380  * \param callerid callerid to search for
381  *
382  * \return If an extension within the given context(or callerid) with the given priority 
383  *         is found a non zero value will be returned. Otherwise, 0 is returned.
384  */
385 int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, 
386         int priority, const char *callerid);
387
388 /*! 
389  * \brief Find the priority of an extension that has the specified label
390  * 
391  * \param c this is not important
392  * \param context which context to look in
393  * \param exten which extension to search for
394  * \param label label of the action within the extension to match to priority
395  * \param callerid callerid to search for
396  *
397  * \return the priority which matches the given label in the extension or -1 if not found.
398  */
399 int ast_findlabel_extension(struct ast_channel *c, const char *context, 
400         const char *exten, const char *label, const char *callerid);
401
402 /*!
403  * \brief Find the priority of an extension that has the specified label
404  *
405  * \note This function is the same as ast_findlabel_extension, except that it accepts
406  * a pointer to an ast_context structure to specify the context instead of the
407  * name of the context. Otherwise, the functions behave the same.
408  */
409 int ast_findlabel_extension2(struct ast_channel *c, struct ast_context *con, 
410         const char *exten, const char *label, const char *callerid);
411
412 /*! 
413  * \brief Looks for a valid matching extension
414  * 
415  * \param c not really important
416  * \param context context to serach within
417  * \param exten extension to check
418  * \param priority priority of extension path
419  * \param callerid callerid of extension being searched for
420  *
421  * \return If "exten" *could be* a valid extension in this context with or without
422  * some more digits, return non-zero.  Basically, when this returns 0, no matter
423  * what you add to exten, it's not going to be a valid extension anymore
424  */
425 int ast_canmatch_extension(struct ast_channel *c, const char *context, 
426         const char *exten, int priority, const char *callerid);
427
428 /*! 
429  * \brief Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
430  *
431  * \param c not really important XXX
432  * \param context context to serach within
433  * \param exten extension to check
434  * \param priority priority of extension path
435  * \param callerid callerid of extension being searched for
436  *
437  * \return If "exten" *could match* a valid extension in this context with
438  * some more digits, return non-zero.  Does NOT return non-zero if this is
439  * an exact-match only.  Basically, when this returns 0, no matter
440  * what you add to exten, it's not going to be a valid extension anymore
441  */
442 int ast_matchmore_extension(struct ast_channel *c, const char *context, 
443         const char *exten, int priority, const char *callerid);
444
445 /*! 
446  * \brief Determine if a given extension matches a given pattern (in NXX format)
447  * 
448  * \param pattern pattern to match
449  * \param extension extension to check against the pattern.
450  *
451  * Checks whether or not the given extension matches the given pattern.
452  *
453  * \retval 1 on match
454  * \retval 0 on failure
455  */
456 int ast_extension_match(const char *pattern, const char *extension);
457
458 int ast_extension_close(const char *pattern, const char *data, int needmore);
459
460 /*! 
461  * \brief Launch a new extension (i.e. new stack)
462  * 
463  * \param c not important
464  * \param context which context to generate the extension within
465  * \param exten new extension to add
466  * \param priority priority of new extension
467  * \param callerid callerid of extension
468  *
469  * This adds a new extension to the asterisk extension list.
470  *
471  * \retval 0 on success 
472  * \retval -1 on failure.
473  */
474 int ast_spawn_extension(struct ast_channel *c, const char *context, 
475         const char *exten, int priority, const char *callerid);
476
477 /*! 
478  * \brief Add a context include
479  *
480  * \param context context to add include to
481  * \param include new include to add
482  * \param registrar who's registering it
483  *
484  * Adds an include taking a char * string as the context parameter
485  *
486  * \retval 0 on success 
487  * \retval -1 on error
488 */
489 int ast_context_add_include(const char *context, const char *include, 
490         const char *registrar);
491
492 /*! 
493  * \brief Add a context include
494  * 
495  * \param con context to add the include to
496  * \param include include to add
497  * \param registrar who registered the context
498  *
499  * Adds an include taking a struct ast_context as the first parameter
500  *
501  * \retval 0 on success 
502  * \retval -1 on failure
503  */
504 int ast_context_add_include2(struct ast_context *con, const char *include, 
505         const char *registrar);
506
507 /*! 
508  * \brief Remove a context include
509  * 
510  * \note See ast_context_add_include for information on arguments
511  *
512  * \retval 0 on success
513  * \retval -1 on failure
514  */
515 int ast_context_remove_include(const char *context, const char *include, 
516         const char *registrar);
517
518 /*! 
519  * \brief Removes an include by an ast_context structure 
520  * 
521  * \note See ast_context_add_include2 for information on arguments
522  *
523  * \retval 0 on success
524  * \retval -1 on success
525  */
526 int ast_context_remove_include2(struct ast_context *con, const char *include, 
527         const char *registrar);
528
529 /*! 
530  * \brief Verifies includes in an ast_contect structure
531  * 
532  * \param con context in which to verify the includes
533  *
534  * \retval 0 if no problems found 
535  * \retval -1 if there were any missing context
536  */
537 int ast_context_verify_includes(struct ast_context *con);
538           
539 /*! 
540  * \brief Add a switch
541  * 
542  * \param context context to which to add the switch
543  * \param sw switch to add
544  * \param data data to pass to switch
545  * \param eval whether to evaluate variables when running switch
546  * \param registrar whoever registered the switch
547  *
548  * This function registers a switch with the asterisk switch architecture
549  *
550  * \retval 0 on success 
551  * \retval -1 on failure
552  */
553 int ast_context_add_switch(const char *context, const char *sw, const char *data, 
554         int eval, const char *registrar);
555
556 /*! 
557  * \brief Adds a switch (first param is a ast_context)
558  * 
559  * \note See ast_context_add_switch() for argument information, with the exception of
560  *       the first argument. In this case, it's a pointer to an ast_context structure
561  *       as opposed to the name.
562  */
563 int ast_context_add_switch2(struct ast_context *con, const char *sw, const char *data, 
564         int eval, const char *registrar);
565
566 /*! 
567  * \brief Remove a switch
568  * 
569  * Removes a switch with the given parameters
570  *
571  * \retval 0 on success 
572  * \retval -1 on failure
573  */
574 int ast_context_remove_switch(const char *context, const char *sw, 
575         const char *data, const char *registrar);
576
577 int ast_context_remove_switch2(struct ast_context *con, const char *sw, 
578         const char *data, const char *registrar);
579
580 /*! 
581  * \brief Simply remove extension from context
582  * 
583  * \param context context to remove extension from
584  * \param extension which extension to remove
585  * \param priority priority of extension to remove
586  * \param registrar registrar of the extension
587  *
588  * This function removes an extension from a given context.
589  *
590  * \retval 0 on success 
591  * \retval -1 on failure
592  */
593 int ast_context_remove_extension(const char *context, const char *extension, int priority,
594         const char *registrar);
595
596 int ast_context_remove_extension2(struct ast_context *con, const char *extension,
597         int priority, const char *registrar);
598
599 /*! 
600  * \brief Add an ignorepat
601  * 
602  * \param context which context to add the ignorpattern to
603  * \param ignorepat ignorepattern to set up for the extension
604  * \param registrar registrar of the ignore pattern
605  *
606  * Adds an ignore pattern to a particular context.
607  *
608  * \retval 0 on success 
609  * \retval -1 on failure
610  */
611 int ast_context_add_ignorepat(const char *context, const char *ignorepat, const char *registrar);
612
613 int ast_context_add_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
614
615 /* 
616  * \brief Remove an ignorepat
617  * 
618  * \param context context from which to remove the pattern
619  * \param ignorepat the pattern to remove
620  * \param registrar the registrar of the ignore pattern
621  *
622  * This removes the given ignorepattern
623  *
624  * \retval 0 on success 
625  * \retval -1 on failure
626  */
627 int ast_context_remove_ignorepat(const char *context, const char *ignorepat, const char *registrar);
628
629 int ast_context_remove_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
630
631 /*! 
632  * \brief Checks to see if a number should be ignored
633  * 
634  * \param context context to search within
635  * \param pattern to check whether it should be ignored or not
636  *
637  * Check if a number should be ignored with respect to dialtone cancellation.
638  *
639  * \retval 0 if the pattern should not be ignored 
640  * \retval non-zero if the pattern should be ignored 
641  */
642 int ast_ignore_pattern(const char *context, const char *pattern);
643
644 /* Locking functions for outer modules, especially for completion functions */
645
646 /*! 
647  * \brief Locks the context list
648  *
649  * \retval 0 on success 
650  * \retval -1 on error
651  */
652 int ast_lock_contexts(void);
653
654 /*! 
655  * \brief Unlocks contexts
656  * 
657  * \retval 0 on success 
658  * \retval -1 on failure
659  */
660 int ast_unlock_contexts(void);
661
662 /*! 
663  * \brief Locks a given context
664  * 
665  * \param con context to lock
666  *
667  * \retval 0 on success 
668  * \retval -1 on failure
669  */
670 int ast_lock_context(struct ast_context *con);
671
672 /*! 
673  * \retval Unlocks the given context
674  * 
675  * \param con context to unlock
676  *
677  * \retval 0 on success 
678  * \retval -1 on failure
679  */
680 int ast_unlock_context(struct ast_context *con);
681
682
683 int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
684
685 int ast_async_goto_by_name(const char *chan, const char *context, const char *exten, int priority);
686
687 /*! Synchronously or asynchronously make an outbound call and send it to a
688    particular extension */
689 int ast_pbx_outgoing_exten(const char *type, int format, void *data, int timeout, const char *context, const char *exten, int priority, int *reason, int sync, const char *cid_num, const char *cid_name, struct ast_variable *vars, const char *account, struct ast_channel **locked_channel);
690
691 /*! Synchronously or asynchronously make an outbound call and send it to a
692    particular application with given extension */
693 int ast_pbx_outgoing_app(const char *type, int format, void *data, 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);
694
695 /* Evaluate a condition for non-falseness and return a boolean */
696 int pbx_checkcondition(char *condition);
697
698 /* Functions for returning values from structures */
699 const char *ast_get_context_name(struct ast_context *con);
700 const char *ast_get_extension_name(struct ast_exten *exten);
701 struct ast_context *ast_get_extension_context(struct ast_exten *exten);
702 const char *ast_get_include_name(struct ast_include *include);
703 const char *ast_get_ignorepat_name(struct ast_ignorepat *ip);
704 const char *ast_get_switch_name(struct ast_sw *sw);
705 const char *ast_get_switch_data(struct ast_sw *sw);
706
707 /* Other extension stuff */
708 int ast_get_extension_priority(struct ast_exten *exten);
709 int ast_get_extension_matchcid(struct ast_exten *e);
710 const char *ast_get_extension_cidmatch(struct ast_exten *e);
711 const char *ast_get_extension_app(struct ast_exten *e);
712 const char *ast_get_extension_label(struct ast_exten *e);
713 void *ast_get_extension_app_data(struct ast_exten *e);
714
715 /* Registrar info functions ... */
716 const char *ast_get_context_registrar(struct ast_context *c);
717 const char *ast_get_extension_registrar(struct ast_exten *e);
718 const char *ast_get_include_registrar(struct ast_include *i);
719 const char *ast_get_ignorepat_registrar(struct ast_ignorepat *ip);
720 const char *ast_get_switch_registrar(struct ast_sw *sw);
721
722 /* Walking functions ... */
723 struct ast_context *ast_walk_contexts(struct ast_context *con);
724 struct ast_exten *ast_walk_context_extensions(struct ast_context *con,
725         struct ast_exten *priority);
726 struct ast_exten *ast_walk_extension_priorities(struct ast_exten *exten,
727         struct ast_exten *priority);
728 struct ast_include *ast_walk_context_includes(struct ast_context *con,
729         struct ast_include *inc);
730 struct ast_ignorepat *ast_walk_context_ignorepats(struct ast_context *con,
731         struct ast_ignorepat *ip);
732 struct ast_sw *ast_walk_context_switches(struct ast_context *con, struct ast_sw *sw);
733
734 int pbx_builtin_serialize_variables(struct ast_channel *chan, char *buf, size_t size);
735 const char *pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name);
736 void pbx_builtin_pushvar_helper(struct ast_channel *chan, const char *name, const char *value);
737 void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value);
738 void pbx_retrieve_variable(struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp);
739 void pbx_builtin_clear_globals(void);
740 int pbx_builtin_setvar(struct ast_channel *chan, void *data);
741 void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
742 void pbx_substitute_variables_varshead(struct varshead *headp, const char *cp1, char *cp2, int count);
743
744 int ast_extension_patmatch(const char *pattern, const char *data);
745
746 /*! Set "autofallthrough" flag, if newval is <0, does not acutally set.  If
747   set to 1, sets to auto fall through.  If newval set to 0, sets to no auto
748   fall through (reads extension instead).  Returns previous value. */
749 int pbx_set_autofallthrough(int newval);
750 int ast_goto_if_exists(struct ast_channel *chan, const char *context, const char *exten, int priority);
751 /* I can find neither parsable nor parseable at dictionary.com, but google gives me 169000 hits for parseable and only 49,800 for parsable */
752 int ast_parseable_goto(struct ast_channel *chan, const char *goto_string);
753 int ast_explicit_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
754 int ast_async_goto_if_exists(struct ast_channel *chan, const char *context, const char *exten, int priority);
755
756 struct ast_custom_function* ast_custom_function_find(const char *name);
757
758 /*!
759  * \brief Unregister a custom function
760  */
761 int ast_custom_function_unregister(struct ast_custom_function *acf);
762
763 /*!
764  * \brief Reigster a custom function
765  */
766 int ast_custom_function_register(struct ast_custom_function *acf);
767
768 /*! 
769  * \brief Retrieve the number of active calls
770  */
771 int ast_active_calls(void);
772         
773 /*!
774  * \brief executes a read operation on a function 
775  *
776  * \param chan Channel to execute on
777  * \param function Data containing the function call string (will be modified)
778  * \param workspace A pointer to safe memory to use for a return value 
779  * \param len the number of bytes in workspace
780  *
781  * This application executes a function in read mode on a given channel.
782  *
783  * \return zero on success, non-zero on failure
784  */
785 int ast_func_read(struct ast_channel *chan, char *function, char *workspace, size_t len);
786
787 /*!
788  * \brief executes a write operation on a function
789  *
790  * \param chan Channel to execute on
791  * \param function Data containing the function call string (will be modified)
792  * \param value A value parameter to pass for writing
793  *
794  * This application executes a function in write mode on a given channel.
795  *
796  * \return zero on success, non-zero on failure
797  */
798 int ast_func_write(struct ast_channel *chan, char *function, const char *value);
799
800 void ast_hint_state_changed(const char *device);
801
802 #if defined(__cplusplus) || defined(c_plusplus)
803 }
804 #endif
805
806 #endif /* _ASTERISK_PBX_H */