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