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