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