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