9828aa6bbc83bb50ea9f8e17fa7b0000aa16769d
[asterisk/asterisk.git] / include / asterisk / pbx.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, 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 /*
20  * 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         char *(*read)(struct ast_channel *, char *, char *, char *, size_t);
92         void (*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 registar 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 /*! Create a new thread and start the PBX (or whatever) */
210 /*!
211  * \param c channel to start the pbx on
212  * Starts a pbx thread on a given channel
213  * It returns -1 on failure, and 0 on success
214  */
215 int ast_pbx_start(struct ast_channel *c);
216
217 /*! Execute the PBX in the current thread */
218 /*!
219  * \param c channel to run the pbx on
220  * This executes the PBX on a given channel.  It allocates a new
221  * PBX structure for the channel, and provides all PBX functionality.
222  */
223 int ast_pbx_run(struct ast_channel *c);
224
225 /*! 
226  * \param context context to add the extension to
227  * \param replace
228  * \param extension extension to add
229  * \param priority priority level of extension addition
230  * \param callerid callerid of extension
231  * \param application application to run on the extension with that priority level
232  * \param data data to pass to the application
233  * \param datad
234  * \param registrar who registered the extension
235  * Add and extension to an extension context.  
236  * Callerid is a pattern to match CallerID, or NULL to match any callerid
237  * Returns 0 on success, -1 on failure
238  */
239 int ast_add_extension(const char *context, int replace, const char *extension, int priority, const char *label, const char *callerid,
240         const char *application, void *data, void (*datad)(void *), const char *registrar);
241
242 /*! 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 */
243 /*! 
244  * For details about the arguements, check ast_add_extension()
245  */
246 int ast_add_extension2(struct ast_context *con,
247                                       int replace, const char *extension, int priority, const char *label, const char *callerid, 
248                                           const char *application, void *data, void (*datad)(void *),
249                                           const char *registrar);
250
251 /*! Add an application.  The function 'execute' should return non-zero if the line needs to be hung up.  */
252 /*!
253   \param app Short name of the application
254   \param execute a function callback to execute the application
255   \param synopsis a short description of the application
256   \param description long description of the application
257    Include a one-line synopsis (e.g. 'hangs up a channel') and a more lengthy, multiline
258    description with more detail, including under what conditions the application
259    will return 0 or -1.
260    This registers an application with asterisks internal application list.  Please note:
261    The individual applications themselves are responsible for registering and unregistering
262    CLI commands.
263    It returns 0 on success, -1 on failure.
264 */
265 int ast_register_application(const char *app, int (*execute)(struct ast_channel *, void *),
266                              const char *synopsis, const char *description);
267
268 /*! Remove an application */
269 /*!
270  * \param app name of the application (does not have to be the same string as the one that was registered)
271  * This unregisters an application from asterisk's internal registration mechanisms.
272  * It returns 0 on success, and -1 on failure.
273  */
274 int ast_unregister_application(const char *app);
275
276 /*! Uses hint and devicestate callback to get the state of an extension */
277 /*!
278  * \param c this is not important
279  * \param context which context to look in
280  * \param exten which extension to get state
281  * Returns extension state !! = AST_EXTENSION_???
282  */
283 int ast_extension_state(struct ast_channel *c, char *context, char *exten);
284
285 /*! Return string of the state of an extension */
286 /*!
287  * \param extension_state is the numerical state delivered by ast_extension_state
288  * Returns the state of an extension as string
289  */
290 const char *ast_extension_state2str(int extension_state);
291
292 /*! Registers a state change callback */
293 /*!
294  * \param context which context to look in
295  * \param exten which extension to get state
296  * \param callback callback to call if state changed
297  * \param data to pass to callback
298  * The callback is called if the state for extension is changed
299  * Return -1 on failure, ID on success
300  */ 
301 int ast_extension_state_add(const char *context, const char *exten, 
302                             ast_state_cb_type callback, void *data);
303
304 /*! Deletes a registered state change callback by ID */
305 /*!
306  * \param id of the callback to delete
307  * Removes the callback from list of callbacks
308  * Return 0 on success, -1 on failure
309  */
310 int ast_extension_state_del(int id, ast_state_cb_type callback);
311
312 /*! If an extension exists, return non-zero */
313 /*!
314  * \param hint buffer for hint
315  * \param maxlen size of hint buffer
316  * \param hint buffer for name portion of hint
317  * \param maxlen size of name buffer
318  * \param c this is not important
319  * \param context which context to look in
320  * \param exten which extension to search for
321  * If an extension within the given context with the priority PRIORITY_HINT
322  * is found a non zero value will be returned.
323  * Otherwise, 0 is returned.
324  */
325 int ast_get_hint(char *hint, int maxlen, char *name, int maxnamelen, struct ast_channel *c, const char *context, const char *exten);
326
327 /*! If an extension exists, return non-zero */
328 /*  work */
329 /*!
330  * \param c this is not important
331  * \param context which context to look in
332  * \param exten which extension to search for
333  * \param priority priority of the action within the extension
334  * \param callerid callerid to search for
335  * If an extension within the given context(or callerid) with the given priority is found a non zero value will be returned.
336  * Otherwise, 0 is returned.
337  */
338 int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid);
339
340 /*! If an extension exists, return non-zero */
341 /*  work */
342 /*!
343  * \param c this is not important
344  * \param context which context to look in
345  * \param exten which extension to search for
346  * \param labellabel of the action within the extension to match to priority
347  * \param callerid callerid to search for
348  * If an priority which matches given label in extension or -1 if not found.
349 \ */
350 int ast_findlabel_extension(struct ast_channel *c, const char *context, const char *exten, const char *label, const char *callerid);
351
352 int ast_findlabel_extension2(struct ast_channel *c, struct ast_context *con, const char *exten, const char *label, const char *callerid);
353
354 /*! Looks for a valid matching extension */
355 /*!
356   \param c not really important
357   \param context context to serach within
358   \param exten extension to check
359   \param priority priority of extension path
360   \param callerid callerid of extension being searched for
361    If "exten" *could be* a valid extension in this context with or without
362    some more digits, return non-zero.  Basically, when this returns 0, no matter
363    what you add to exten, it's not going to be a valid extension anymore
364 */
365 int ast_canmatch_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid);
366
367 /*! Looks to see if adding anything to this extension might match something. (exists ^ canmatch) */
368 /*!
369   \param c not really important
370   \param context context to serach within
371   \param exten extension to check
372   \param priority priority of extension path
373   \param callerid callerid of extension being searched for
374    If "exten" *could match* a valid extension in this context with
375    some more digits, return non-zero.  Does NOT return non-zero if this is
376    an exact-match only.  Basically, when this returns 0, no matter
377    what you add to exten, it's not going to be a valid extension anymore
378 */
379 int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid);
380
381 /*! Determine if a given extension matches a given pattern (in NXX format) */
382 /*!
383  * \param pattern pattern to match
384  * \param extension extension to check against the pattern.
385  * Checks whether or not the given extension matches the given pattern.
386  * Returns 1 on match, 0 on failure
387  */
388 int ast_extension_match(const char *pattern, const char *extension);
389 int ast_extension_close(const char *pattern, const char *data, int needmore);
390 /*! Launch a new extension (i.e. new stack) */
391 /*!
392  * \param c not important
393  * \param context which context to generate the extension within
394  * \param exten new extension to add
395  * \param priority priority of new extension
396  * \param callerid callerid of extension
397  * This adds a new extension to the asterisk extension list.
398  * It returns 0 on success, -1 on failure.
399  */
400 int ast_spawn_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid);
401
402 /*! Execute an extension. */
403 /*!
404   \param c channel to execute upon
405   \param context which context extension is in
406   \param exten extension to execute
407   \param priority priority to execute within the given extension
408    If it's not available, do whatever you should do for
409    default extensions and halt the thread if necessary.  This function does not
410    return, except on error.
411 */
412 int ast_exec_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid);
413
414 /*! Add an include */
415 /*!
416   \param context context to add include to
417   \param include new include to add
418   \param registrar who's registering it
419    Adds an include taking a char * string as the context parameter
420    Returns 0 on success, -1 on error
421 */
422 int ast_context_add_include(const char *context, const char *include, const char *registrar);
423
424 /*! Add an include */
425 /*!
426   \param con context to add the include to
427   \param include include to add
428   \param registrar who registered the context
429    Adds an include taking a struct ast_context as the first parameter
430    Returns 0 on success, -1 on failure
431 */
432 int ast_context_add_include2(struct ast_context *con, const char *include, const char *registrar);
433
434 /*! Removes an include */
435 /*!
436  * See add_include
437  */
438 int ast_context_remove_include(const char *context, const char *include,const  char *registrar);
439 /*! Removes an include by an ast_context structure */
440 /*!
441  * See add_include2
442  */
443 int ast_context_remove_include2(struct ast_context *con, const char *include, const char *registrar);
444
445 /*! Verifies includes in an ast_contect structure */
446 /*!
447  * \param con context in which to verify the includes
448  * Returns 0 if no problems found, -1 if there were any missing context
449  */
450 int ast_context_verify_includes(struct ast_context *con);
451           
452 /*! Add a switch */
453 /*!
454  * \param context context to which to add the switch
455  * \param sw switch to add
456  * \param data data to pass to switch
457  * \param eval whether to evaluate variables when running switch
458  * \param registrar whoever registered the switch
459  * This function registers a switch with the asterisk switch architecture
460  * It returns 0 on success, -1 on failure
461  */
462 int ast_context_add_switch(const char *context, const char *sw, const char *data, int eval, const char *registrar);
463 /*! Adds a switch (first param is a ast_context) */
464 /*!
465  * See ast_context_add_switch()
466  */
467 int ast_context_add_switch2(struct ast_context *con, const char *sw, const char *data, int eval, const char *registrar);
468
469 /*! Remove a switch */
470 /*!
471  * Removes a switch with the given parameters
472  * Returns 0 on success, -1 on failure
473  */
474 int ast_context_remove_switch(const char *context, const char *sw, const char *data, const char *registrar);
475 int ast_context_remove_switch2(struct ast_context *con, const char *sw, const char *data, const char *registrar);
476
477 /*! Simply remove extension from context */
478 /*!
479  * \param context context to remove extension from
480  * \param extension which extension to remove
481  * \param priority priority of extension to remove
482  * \param registrar registrar of the extension
483  * This function removes an extension from a given context.
484  * Returns 0 on success, -1 on failure
485  */
486 int ast_context_remove_extension(const char *context, const char *extension, int priority,
487         const char *registrar);
488 int ast_context_remove_extension2(struct ast_context *con, const char *extension,
489         int priority, const char *registrar);
490
491 /*! Add an ignorepat */
492 /*!
493  * \param context which context to add the ignorpattern to
494  * \param ignorpat ignorepattern to set up for the extension
495  * \param registrar registrar of the ignore pattern
496  * Adds an ignore pattern to a particular context.
497  * Returns 0 on success, -1 on failure
498  */
499 int ast_context_add_ignorepat(const char *context, const char *ignorepat, const char *registrar);
500 int ast_context_add_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
501
502 /* Remove an ignorepat */
503 /*!
504  * \param context context from which to remove the pattern
505  * \param ignorepat the pattern to remove
506  * \param registrar the registrar of the ignore pattern
507  * This removes the given ignorepattern
508  * Returns 0 on success, -1 on failure
509  */
510 int ast_context_remove_ignorepat(const char *context, const char *ignorepat, const char *registrar);
511 int ast_context_remove_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar);
512
513 /*! Checks to see if a number should be ignored */
514 /*!
515  * \param context context to search within
516  * \param extension to check whether it should be ignored or not
517  * Check if a number should be ignored with respect to dialtone cancellation.  
518  * Returns 0 if the pattern should not be ignored, or non-zero if the pattern should be ignored 
519  */
520 int ast_ignore_pattern(const char *context, const char *pattern);
521
522 /* Locking functions for outer modules, especially for completion functions */
523 /*! Locks the contexts */
524 /*! Locks the context list
525  * Returns 0 on success, -1 on error
526  */
527 int ast_lock_contexts(void);
528
529 /*! Unlocks contexts */
530 /*!
531  * Returns 0 on success, -1 on failure
532  */
533 int ast_unlock_contexts(void);
534
535 /*! Locks a given context */
536 /*!
537  * \param con context to lock
538  * Locks the context.
539  * Returns 0 on success, -1 on failure
540  */
541 int ast_lock_context(struct ast_context *con);
542 /*! Unlocks the given context */
543 /*!
544  * \param con context to unlock
545  * Unlocks the given context
546  * Returns 0 on success, -1 on failure
547  */
548 int ast_unlock_context(struct ast_context *con);
549
550
551 int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
552
553 int ast_async_goto_by_name(const char *chan, const char *context, const char *exten, int priority);
554
555 /* Synchronously or asynchronously make an outbound call and send it to a
556    particular extension */
557 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, struct ast_channel **locked_channel);
558
559 /* Synchronously or asynchronously make an outbound call and send it to a
560    particular application with given extension */
561 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, struct ast_channel **locked_channel);
562
563 /* Functions for returning values from structures */
564 const char *ast_get_context_name(struct ast_context *con);
565 const char *ast_get_extension_name(struct ast_exten *exten);
566 const char *ast_get_include_name(struct ast_include *include);
567 const char *ast_get_ignorepat_name(struct ast_ignorepat *ip);
568 const char *ast_get_switch_name(struct ast_sw *sw);
569 const char *ast_get_switch_data(struct ast_sw *sw);
570
571 /* Other extension stuff */
572 int ast_get_extension_priority(struct ast_exten *exten);
573 int ast_get_extension_matchcid(struct ast_exten *e);
574 const char *ast_get_extension_cidmatch(struct ast_exten *e);
575 const char *ast_get_extension_app(struct ast_exten *e);
576 const char *ast_get_extension_label(struct ast_exten *e);
577 void *ast_get_extension_app_data(struct ast_exten *e);
578
579 /* Registrar info functions ... */
580 const char *ast_get_context_registrar(struct ast_context *c);
581 const char *ast_get_extension_registrar(struct ast_exten *e);
582 const char *ast_get_include_registrar(struct ast_include *i);
583 const char *ast_get_ignorepat_registrar(struct ast_ignorepat *ip);
584 const char *ast_get_switch_registrar(struct ast_sw *sw);
585
586 /* Walking functions ... */
587 struct ast_context *ast_walk_contexts(struct ast_context *con);
588 struct ast_exten *ast_walk_context_extensions(struct ast_context *con,
589         struct ast_exten *priority);
590 struct ast_exten *ast_walk_extension_priorities(struct ast_exten *exten,
591         struct ast_exten *priority);
592 struct ast_include *ast_walk_context_includes(struct ast_context *con,
593         struct ast_include *inc);
594 struct ast_ignorepat *ast_walk_context_ignorepats(struct ast_context *con,
595         struct ast_ignorepat *ip);
596 struct ast_sw *ast_walk_context_switches(struct ast_context *con, struct ast_sw *sw);
597
598 int pbx_builtin_serialize_variables(struct ast_channel *chan, char *buf, size_t size);
599 extern char *pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name);
600 extern void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value);
601 extern void pbx_retrieve_variable(struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp);
602 extern void pbx_builtin_clear_globals(void);
603 extern int pbx_builtin_setvar(struct ast_channel *chan, void *data);
604 extern void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
605 extern void pbx_substitute_variables_varshead(struct varshead *headp, const char *cp1, char *cp2, int count);
606
607 int ast_extension_patmatch(const char *pattern, const char *data);
608
609 /* Set "autofallthrough" flag, if newval is <0, does not acutally set.  If
610   set to 1, sets to auto fall through.  If newval set to 0, sets to no auto
611   fall through (reads extension instead).  Returns previous value. */
612 extern int pbx_set_autofallthrough(int newval);
613 int ast_goto_if_exists(struct ast_channel *chan, char* context, char *exten, int priority);
614 /* I can find neither parsable nor parseable at dictionary.com, but google gives me 169000 hits for parseable and only 49,800 for parsable */
615 int ast_parseable_goto(struct ast_channel *chan, const char *goto_string);
616 int ast_explicit_goto(struct ast_channel *chan, const char *context, const char *exten, int priority);
617 int ast_async_goto_if_exists(struct ast_channel *chan, char* context, char *exten, int priority);
618
619 struct ast_custom_function* ast_custom_function_find(char *name);
620 int ast_custom_function_unregister(struct ast_custom_function *acf);
621 int ast_custom_function_register(struct ast_custom_function *acf);
622
623 /* Number of active calls */
624 int ast_active_calls(void);
625         
626 /*! executes a read operation on a function */
627 /*!
628  * \param chan Channel to execute on
629  * \param in Data containing the function call string
630  * \param workspace A pointer to safe memory to use for a return value 
631  * \param len the number of bytes in workspace
632  * This application executes an function in read mode on a given channel.
633  * It returns a pointer to workspace if the buffer contains any new data
634  * or NULL if there was a problem.
635  */
636         
637 char *ast_func_read(struct ast_channel *chan, const char *in, char *workspace, size_t len);
638
639 /*! executes a write operation on a function */
640 /*!
641  * \param chan Channel to execute on
642  * \param in Data containing the function call string
643  * \param value A value parameter to pass for writing
644  * This application executes an function in write mode on a given channel.
645  * It has no return value.
646  */
647 void ast_func_write(struct ast_channel *chan, const char *in, const char *value);
648
649 void ast_hint_state_changed(const char *device);
650
651 #if defined(__cplusplus) || defined(c_plusplus)
652 }
653 #endif
654
655 #endif /* _ASTERISK_PBX_H */