3ab0f647abf23b52d3a8e4c6c4b83380b20a2111
[asterisk/asterisk.git] / include / asterisk / channel.h
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * General Asterisk channel definitions.
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #ifndef _ASTERISK_CHANNEL_H
15 #define _ASTERISK_CHANNEL_H
16
17 #include <asterisk/frame.h>
18 #include <asterisk/sched.h>
19 #include <asterisk/chanvars.h>
20 #include <setjmp.h>
21 #include <pthread.h>
22
23 #if defined(__cplusplus) || defined(c_plusplus)
24 extern "C" {
25 #endif
26
27 #include <asterisk/lock.h>
28
29 //! Max length of an extension
30 #define AST_MAX_EXTENSION 80
31
32 #include <asterisk/cdr.h>
33 #include <asterisk/monitor.h>
34
35
36 #define AST_CHANNEL_NAME 80
37 #define AST_CHANNEL_MAX_STACK 32
38
39 #define MAX_LANGUAGE 20
40
41
42 #define AST_MAX_FDS 4
43
44 struct ast_generator {
45         void *(*alloc)(struct ast_channel *chan, void *params);
46         void (*release)(struct ast_channel *chan, void *data);
47         int (*generate)(struct ast_channel *chan, void *data, int len, int samples);
48 };
49
50 //! Main Channel structure associated with a channel.
51 /*! 
52  * This is the side of it mostly used by the pbx and call management.
53  */
54 struct ast_channel {
55         /*! ASCII Description of channel name */
56         char name[AST_CHANNEL_NAME];            
57         /*! Language requested */
58         char language[MAX_LANGUAGE];            
59         /*! Type of channel */
60         char *type;                             
61         /*! File descriptor for channel -- Drivers will poll on these file descriptors, so at least one must be non -1.  */
62         int fds[AST_MAX_FDS];                   
63
64         /*! Default music class */
65         char musicclass[MAX_LANGUAGE];
66
67         /*! Current generator data if there is any */
68         void *generatordata;
69         /*! Current active data generator */
70         struct ast_generator *generator;
71         /*! Whether or not the generator should be interrupted by write */
72         int writeinterrupt;
73
74         /*! Who are we bridged to, if we're bridged */
75         struct ast_channel *bridge;             
76         /*! Channel that will masquerade as us */
77         struct ast_channel *masq;               
78         /*! Who we are masquerading as */
79         struct ast_channel *masqr;              
80         /*! Call Detail Record Flags */
81         int cdrflags;                                                                              
82         /*! Whether or not we're blocking */
83         int blocking;                           
84         /*! Whether or not we have been hung up...  Do not set this value
85             directly, use ast_softhangup */
86         int _softhangup;                                
87         /*! Non-zero if this is a zombie channel */
88         int zombie;                                     
89         /*! Non-zero, set to actual time when channel is to be hung up */
90         time_t  whentohangup;
91         /*! If anyone is blocking, this is them */
92         pthread_t blocker;                      
93         /*! Lock, can be used to lock a channel for some operations */
94         pthread_mutex_t lock;                   
95         /*! Procedure causing blocking */
96         char *blockproc;                        
97
98         /*! Current application */
99         char *appl;                             
100         /*! Data passed to current application */
101         char *data;                             
102         
103         /*! Has an exception been detected */
104         int exception;                          
105         /*! Which fd had an event detected on */
106         int fdno;                               
107         /*! Schedule context */
108         struct sched_context *sched;            
109         /*! For streaming playback, the schedule ID */
110         int streamid;                           
111         /*! Stream itself. */
112         struct ast_filestream *stream;          
113         /*! Original writer format */
114         int oldwriteformat;                     
115
116
117         /*! State of line -- Don't write directly, use ast_setstate */
118         int _state;                             
119         /*! Number of rings so far */
120         int rings;                              
121         /*! Current level of application */
122         int stack;                              
123
124
125         /*! Kinds of data this channel can natively handle */
126         int nativeformats;                      
127         /*! Requested read format */
128         int readformat;                         
129         /*! Requested write format */
130         int writeformat;                        
131
132         
133         /*! Malloc'd Dialed Number Identifier */
134         char *dnid;                             
135         /*! Malloc'd Caller ID */
136         char *callerid;                         
137         /*! Malloc'd ANI */
138         char *ani;                      
139         /*! Malloc'd RDNIS */
140         char *rdnis;
141
142         
143         /*! Current extension context */
144         char context[AST_MAX_EXTENSION];        
145         /*! Current extension number */
146         char exten[AST_MAX_EXTENSION];          
147         /* Current extension priority */
148         int priority;                                           
149         /*! Application information -- see assigned numbers */
150         void *app[AST_CHANNEL_MAX_STACK];       
151         /*! Any/all queued DTMF characters */
152         char dtmfq[AST_MAX_EXTENSION];          
153         /*! Are DTMF digits being deferred */
154         int deferdtmf;                          
155         /*! DTMF frame */
156         struct ast_frame dtmff;                 
157         /*! Private channel implementation details */
158         struct ast_channel_pvt *pvt;
159
160                                                 
161         /*! Jump buffer used for returning from applications */
162         jmp_buf jmp[AST_CHANNEL_MAX_STACK];     
163
164         struct ast_pbx *pbx;
165         /*! Set BEFORE PBX is started to determine AMA flags */
166         int     amaflags;                       
167         /*! Account code for billing */
168         char    accountcode[20];                
169         /*! Call Detail Record */
170         struct ast_cdr *cdr;                    
171         /*! Whether or not ADSI is detected on CPE */
172         int     adsicpe;
173         /*! Where to forward to if asked to dial on this interface */
174         char call_forward[AST_MAX_EXTENSION];
175
176         /*! Tone zone */
177         struct tone_zone *zone;
178
179         /* Channel monitoring */
180         struct ast_channel_monitor *monitor;
181
182         /* Frames in/out counters */
183         unsigned int fin;
184         unsigned int fout;
185
186         /* A linked list for variables */
187         struct ast_var_t *vars; 
188         AST_LIST_HEAD(varshead,ast_var_t) varshead;
189
190         unsigned int callgroup;
191         unsigned int pickupgroup;
192         
193         /*! For easy linking */
194         struct ast_channel *next;               
195
196 };
197
198 struct chanmon;
199
200 #define AST_CDR_TRANSFER        (1 << 0)
201 #define AST_CDR_FORWARD         (1 << 1)
202 #define AST_CDR_CALLWAIT        (1 << 2)
203 #define AST_CDR_CONFERENCE      (1 << 3)
204
205 #define AST_ADSI_UNKNOWN        (0)
206 #define AST_ADSI_AVAILABLE      (1)
207 #define AST_ADSI_UNAVAILABLE    (2)
208 #define AST_ADSI_OFFHOOKONLY    (3)
209
210 #define AST_SOFTHANGUP_DEV                      (1 << 0)        /* Soft hangup by device */
211 #define AST_SOFTHANGUP_ASYNCGOTO        (1 << 1)        /* Soft hangup for async goto */
212 #define AST_SOFTHANGUP_SHUTDOWN         (1 << 2)
213 #define AST_SOFTHANGUP_TIMEOUT          (1 << 3)
214 #define AST_SOFTHANGUP_APPUNLOAD        (1 << 4)
215 #define AST_SOFTHANGUP_EXPLICIT         (1 << 5)
216
217 /* Bits 0-15 of state are reserved for the state (up/down) of the line */
218 /*! Channel is down and available */
219 #define AST_STATE_DOWN          0               
220 /*! Channel is down, but reserved */
221 #define AST_STATE_RESERVED      1               
222 /*! Channel is off hook */
223 #define AST_STATE_OFFHOOK       2               
224 /*! Digits (or equivalent) have been dialed */
225 #define AST_STATE_DIALING       3               
226 /*! Line is ringing */
227 #define AST_STATE_RING          4               
228 /*! Remote end is ringing */
229 #define AST_STATE_RINGING       5               
230 /*! Line is up */
231 #define AST_STATE_UP            6               
232 /*! Line is busy */
233 #define AST_STATE_BUSY          7               
234
235 /* Bits 16-32 of state are reserved for flags */
236 /*! Do not transmit voice data */
237 #define AST_STATE_MUTE          (1 << 16)       
238
239 /*! Device is valid but channel didn't know state */
240 #define AST_DEVICE_UNKNOWN      0
241 /*! Device is not used */
242 #define AST_DEVICE_NOT_INUSE    1
243 /*! Device is in use */
244 #define AST_DEVICE_INUSE        2
245 /*! Device is busy */
246 #define AST_DEVICE_BUSY         3
247 /*! Device is invalid */
248 #define AST_DEVICE_INVALID      4
249 /*! Device is unavailable */
250 #define AST_DEVICE_UNAVAILABLE  5
251
252 //! Requests a channel
253 /*! 
254  * \param type type of channel to request
255  * \param format requested channel format
256  * \param data data to pass to the channel requester
257  * Request a channel of a given type, with data as optional information used 
258  * by the low level module
259  * Returns an ast_channel on success, NULL on failure.
260  */
261 struct ast_channel *ast_request(char *type, int format, void *data);
262
263 //! Search the Channels by Name
264 /*!
265  * \param device like a dialstring
266  * Search the Device in active channels by compare the channelname against 
267  * the devicename. Compared are only the first chars to the first '-' char.
268  * Returns an AST_DEVICE_UNKNOWN if no channel found or
269  * AST_DEVICE_INUSE if a channel is found
270  */
271 int ast_parse_device_state(char *device);
272
273 //! Asks a channel for device state
274 /*!
275  * \param device like a dialstring
276  * Asks a channel for device state, data is  normaly a number from dialstring
277  * used by the low level module
278  * Trys the channel devicestate callback if not supported search in the
279  * active channels list for the device.
280  * Returns an AST_DEVICE_??? state -1 on failure
281  */
282 int ast_device_state(char *device);
283
284 /*!
285  * \param type type of channel to request
286  * \param format requested channel format
287  * \param data data to pass to the channel requester
288  * \param timeout maximum amount of time to wait for an answer
289  * \param why unsuccessful (if unsuceessful)
290  * Request a channel of a given type, with data as optional information used 
291  * by the low level module and attempt to place a call on it
292  * Returns an ast_channel on success or no answer, NULL on failure.  Check the value of chan->_state
293  * to know if the call was answered or not.
294  */
295 struct ast_channel *ast_request_and_dial(char *type, int format, void *data, int timeout, int *reason, char *callerid);
296
297 //! Registers a channel
298 /*! 
299  * \param type type of channel you are registering
300  * \param description short description of the channel
301  * \param capabilities a bit mask of the capabilities of the channel
302  * \param requester a function pointer that properly responds to a call.  See one of the channel drivers for details.
303  * Called by a channel module to register the kind of channels it supports.
304  * It supplies a brief type, a longer, but still short description, and a
305  * routine that creates a channel
306  * Returns 0 on success, -1 on failure.
307  */
308 int ast_channel_register(char *type, char *description, int capabilities, 
309                         struct ast_channel* (*requester)(char *type, int format, void *data));
310
311 /* Same like the upper function but with support for devicestate */
312 int ast_channel_register_ex(char *type, char *description, int capabilities,
313                 struct ast_channel *(*requester)(char *type, int format, void *data),
314                 int (*devicestate)(void *data));
315
316 //! Unregister a channel class
317 /*
318  * \param type the character string that corresponds to the channel you wish to unregister
319  * Basically just unregisters the channel with the asterisk channel system
320  * No return value.
321  */
322 void ast_channel_unregister(char *type);
323
324 //! Hang up a channel 
325 /*! 
326  * \param chan channel to hang up
327  * This function performs a hard hangup on a channel.  Unlike the soft-hangup, this function
328  * performs all stream stopping, etc, on the channel that needs to end.
329  * chan is no longer valid after this call.
330  * Returns 0 on success, -1 on failure.
331  */
332 int ast_hangup(struct ast_channel *chan);
333
334 //! Softly hangup up a channel
335 /*! 
336  * \param chan channel to be soft-hung-up
337  * Call the protocol layer, but don't destroy the channel structure (use this if you are trying to
338  * safely hangup a channel managed by another thread.
339  * Returns 0 regardless
340  */
341 int ast_softhangup(struct ast_channel *chan, int cause);
342 int ast_softhangup_nolock(struct ast_channel *chan, int cause);
343
344 //! Check to see if a channel is needing hang up
345 /*! 
346  * \param chan channel on which to check for hang up
347  * This function determines if the channel is being requested to be hung up.
348  * Returns 0 if not, or 1 if hang up is requested (including time-out).
349  */
350 int ast_check_hangup(struct ast_channel *chan);
351
352 //! Set when to hang a channel up
353 /*! 
354  * \param chan channel on which to check for hang up
355  * \param offset offset in seconds from current time of when to hang up
356  * This function sets the absolute time out on a channel (when to hang up).
357  */
358 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset);
359
360 //! Answer a ringing call
361 /*!
362  * \param chan channel to answer
363  * This function answers a channel and handles all necessary call
364  * setup functions.
365  * Returns 0 on success, -1 on failure
366  */
367 int ast_answer(struct ast_channel *chan);
368
369 //! Make a call
370 /*! 
371  * \param chan which channel to make the call on
372  * \param addr destination of the call
373  * \param timeout time to wait on for connect
374  * Place a call, take no longer than timeout ms.  Returns -1 on failure, 
375    0 on not enough time (does not auto matically stop ringing), and  
376    the number of seconds the connect took otherwise.
377    Returns 0 on success, -1 on failure
378    */
379 int ast_call(struct ast_channel *chan, char *addr, int timeout);
380
381 //! Indicates condition of channel
382 /*! 
383  * \param chan channel to change the indication
384  * \param condition which condition to indicate on the channel
385  * Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel
386  * Returns 0 on success, -1 on failure
387  */
388 int ast_indicate(struct ast_channel *chan, int condition);
389
390 /* Misc stuff */
391
392 //! Wait for input on a channel
393 /*! 
394  * \param chan channel to wait on
395  * \param ms length of time to wait on the channel
396  * Wait for input on a channel for a given # of milliseconds (<0 for indefinite). 
397   Returns < 0 on  failure, 0 if nothing ever arrived, and the # of ms remaining otherwise */
398 int ast_waitfor(struct ast_channel *chan, int ms);
399
400 //! Wait for a specied amount of time, looking for hangups
401 /*!
402  * \param chan channel to wait for
403  * \param ms length of time in milliseconds to sleep
404  * Waits for a specified amount of time, servicing the channel as required.
405  * returns -1 on hangup, otherwise 0.
406  */
407 int ast_safe_sleep(struct ast_channel *chan, int ms);
408
409 //! Wait for a specied amount of time, looking for hangups and a condition argument
410 /*!
411  * \param chan channel to wait for
412  * \param ms length of time in milliseconds to sleep
413  * \param cond a function pointer for testing continue condition
414  * \param data argument to be passed to the condition test function
415  * Waits for a specified amount of time, servicing the channel as required. If cond
416  * returns 0, this function returns.
417  * returns -1 on hangup, otherwise 0.
418  */
419 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data );
420
421 //! Waits for activity on a group of channels
422 /*! 
423  * \param chan an array of pointers to channels
424  * \param n number of channels that are to be waited upon
425  * \param fds an array of fds to wait upon
426  * \param nfds the number of fds to wait upon
427  * \param exception exception flag
428  * \param outfd fd that had activity on it
429  * \param ms how long the wait was
430  * Big momma function here.  Wait for activity on any of the n channels, or any of the nfds
431    file descriptors.  Returns the channel with activity, or NULL on error or if an FD
432    came first.  If the FD came first, it will be returned in outfd, otherwise, outfd
433    will be -1 */
434 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **chan, int n, int *fds, int nfds, int *exception, int *outfd, int *ms);
435
436 //! Waits for input on a group of channels
437 /*! Wait for input on an array of channels for a given # of milliseconds. Return channel
438    with activity, or NULL if none has activity.  time "ms" is modified in-place, if applicable */
439 struct ast_channel *ast_waitfor_n(struct ast_channel **chan, int n, int *ms);
440
441 //! Waits for input on an fd
442 /*! This version works on fd's only.  Be careful with it. */
443 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception);
444
445
446 //! Reads a frame
447 /*! 
448  * \param chan channel to read a frame from
449  * Read a frame.  Returns a frame, or NULL on error.  If it returns NULL, you
450    best just stop reading frames and assume the channel has been
451    disconnected. */
452 struct ast_frame *ast_read(struct ast_channel *chan);
453
454 //! Write a frame to a channel
455 /*!
456  * \param chan destination channel of the frame
457  * \param frame frame that will be written
458  * This function writes the given frame to the indicated channel.
459  * It returns 0 on success, -1 on failure.
460  */
461 int ast_write(struct ast_channel *chan, struct ast_frame *frame);
462
463 //! Sets read format on channel chan
464 /*! 
465  * \param chan channel to change
466  * \param format format to change to
467  * Set read format for channel to whichever component of "format" is best. 
468  * Returns 0 on success, -1 on failure
469  */
470 int ast_set_read_format(struct ast_channel *chan, int format);
471
472 //! Sets write format on channel chan
473 /*! 
474  * \param chan channel to change
475  * \param format new format for writing
476  * Set write format for channel to whichever compoent of "format" is best. 
477  * Returns 0 on success, -1 on failure
478  */
479 int ast_set_write_format(struct ast_channel *chan, int format);
480
481 //! Sends text to a channel
482 /*! 
483  * \param chan channel to act upon
484  * \param text string of text to send on the channel
485  * Write text to a display on a channel
486  * Returns 0 on success, -1 on failure
487  */
488 int ast_sendtext(struct ast_channel *chan, char *text);
489
490 //! Receives a text character from a channel
491 /*! 
492  * \param chan channel to act upon
493  * \param timeout timeout in milliseconds (0 for infinite wait)
494  * Read a char of text from a channel
495  * Returns 0 on success, -1 on failure
496  */
497 int ast_recvchar(struct ast_channel *chan, int timeout);
498
499 //! Browse channels in use
500 /*! 
501  * \param prev where you want to start in the channel list
502  * Browse the channels currently in use 
503  * Returns the next channel in the list, NULL on end.
504  */
505 struct ast_channel *ast_channel_walk(struct ast_channel *prev);
506
507 //! Waits for a digit
508 /*! 
509  * \param c channel to wait for a digit on
510  * \param ms how many milliseconds to wait
511  * Wait for a digit.  Returns <0 on error, 0 on no entry, and the digit on success. */
512 char ast_waitfordigit(struct ast_channel *c, int ms);
513
514 /* Same as above with audio fd for outputing read audio and ctrlfd to monitor for
515    reading. Returns 1 if ctrlfd becomes available */
516 char ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int ctrlfd);
517
518 //! Reads multiple digits
519 /*! 
520  * \param c channel to read from
521  * \param s string to read in to.  Must be at least the size of your length
522  * \param len how many digits to read (maximum)
523  * \param timeout how long to timeout between digits
524  * \param rtimeout timeout to wait on the first digit
525  * \param enders digits to end the string
526  * Read in a digit string "s", max length "len", maximum timeout between 
527    digits "timeout" (-1 for none), terminated by anything in "enders".  Give them rtimeout
528    for the first digit.  Returns 0 on normal return, or 1 on a timeout.  In the case of
529    a timeout, any digits that were read before the timeout will still be available in s.  
530    RETURNS 2 in full version when ctrlfd is available, NOT 1*/
531 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders);
532 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders, int audiofd, int ctrlfd);
533
534 /*! Report DTMF on channel 0 */
535 #define AST_BRIDGE_DTMF_CHANNEL_0               (1 << 0)                
536 /*! Report DTMF on channel 1 */
537 #define AST_BRIDGE_DTMF_CHANNEL_1               (1 << 1)                
538 /*! Return all voice frames on channel 0 */
539 #define AST_BRIDGE_REC_CHANNEL_0                (1 << 2)                
540 /*! Return all voice frames on channel 1 */
541 #define AST_BRIDGE_REC_CHANNEL_1                (1 << 3)                
542 /*! Ignore all signal frames except NULL */
543 #define AST_BRIDGE_IGNORE_SIGS                  (1 << 4)                
544
545
546 //! Makes two channel formats compatible
547 /*! 
548  * \param c0 first channel to make compatible
549  * \param c1 other channel to make compatible
550  * Set two channels to compatible formats -- call before ast_channel_bridge in general .  Returns 0 on success
551    and -1 if it could not be done */
552 int ast_channel_make_compatible(struct ast_channel *c0, struct ast_channel *c1);
553
554 //! Bridge two channels together
555 /*! 
556  * \param c0 first channel to bridge
557  * \param c1 second channel to bridge
558  * \param flags for the channels
559  * \param fo destination frame(?)
560  * \param rc destination channel(?)
561  * Bridge two channels (c0 and c1) together.  If an important frame occurs, we return that frame in
562    *rf (remember, it could be NULL) and which channel (0 or 1) in rc */
563 int ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc);
564
565 //! Weird function made for call transfers
566 /*! 
567  * \param original channel to make a copy of
568  * \param clone copy of the original channel
569  * This is a very strange and freaky function used primarily for transfer.  Suppose that
570    "original" and "clone" are two channels in random situations.  This function takes
571    the guts out of "clone" and puts them into the "original" channel, then alerts the
572    channel driver of the change, asking it to fixup any private information (like the
573    p->owner pointer) that is affected by the change.  The physical layer of the original
574    channel is hung up.  */
575 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone);
576
577 //! Gives the string form of a given state
578 /*! 
579  * \param state state to get the name of
580  * Give a name to a state 
581  * Pretty self explanatory.
582  * Returns the text form of the binary state given
583  */
584 char *ast_state2str(int state);
585
586 /* Options: Some low-level drivers may implement "options" allowing fine tuning of the
587    low level channel.  See frame.h for options.  Note that many channel drivers may support
588    none or a subset of those features, and you should not count on this if you want your
589    asterisk application to be portable.  They're mainly useful for tweaking performance */
590
591 //! Sets an option on a channel
592 /*! 
593  * \param channel channel to set options on
594  * \param option option to change
595  * \param data data specific to option
596  * \param datalen length of the data
597  * \param block blocking or not
598  * Set an option on a channel (see frame.h), optionally blocking awaiting the reply 
599  * Returns 0 on success and -1 on failure
600  */
601 int ast_channel_setoption(struct ast_channel *channel, int option, void *data, int datalen, int block);
602
603 //! Checks the value of an option
604 /*! 
605  * Query the value of an option, optionally blocking until a reply is received
606  * Works similarly to setoption except only reads the options.
607  */
608 struct ast_frame *ast_channel_queryoption(struct ast_channel *channel, int option, void *data, int *datalen, int block);
609
610 //! Checks for HTML support on a channel
611 /*! Returns 0 if channel does not support HTML or non-zero if it does */
612 int ast_channel_supports_html(struct ast_channel *channel);
613
614 //! Sends HTML on given channel
615 /*! Send HTML or URL on link.  Returns 0 on success or -1 on failure */
616 int ast_channel_sendhtml(struct ast_channel *channel, int subclass, char *data, int datalen);
617
618 //! Sends a URL on a given link
619 /*! Send URL on link.  Returns 0 on success or -1 on failure */
620 int ast_channel_sendurl(struct ast_channel *channel, char *url);
621
622 //! Defers DTMF
623 /*! Defer DTMF so that you only read things like hangups and audio.  Returns
624    non-zero if channel was already DTMF-deferred or 0 if channel is just now
625    being DTMF-deferred */
626 int ast_channel_defer_dtmf(struct ast_channel *chan);
627
628 //! Undeos a defer
629 /*! Undo defer.  ast_read will return any dtmf characters that were queued */
630 void ast_channel_undefer_dtmf(struct ast_channel *chan);
631
632 /*! Initiate system shutdown -- prevents new channels from being allocated.
633     If "hangup" is non-zero, all existing channels will receive soft
634      hangups */
635 void ast_begin_shutdown(int hangup);
636
637 /*! Cancels an existing shutdown and returns to normal operation */
638 void ast_cancel_shutdown(void);
639
640 /*! Returns number of active/allocated channels */
641 int ast_active_channels(void);
642
643 /*! Returns non-zero if Asterisk is being shut down */
644 int ast_shutting_down(void);
645
646 /*! Activate a given generator */
647 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params);
648
649 /*! Deactive an active generator */
650 void ast_deactivate_generator(struct ast_channel *chan);
651
652 void ast_set_callerid(struct ast_channel *chan, char *callerid, int  anitoo);
653
654 /*! Start a tone going */
655 int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
656 /*! Stop a tone from playing */
657 void ast_tonepair_stop(struct ast_channel *chan);
658 /*! Play a tone pair for a given amount of time */
659 int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
660
661 /*! Automatically service a channel for us... */
662 int ast_autoservice_start(struct ast_channel *chan);
663
664 /*! Stop servicing a channel for us...  Returns -1 on error or if channel has been hungup */
665 int ast_autoservice_stop(struct ast_channel *chan);
666
667 #ifdef DO_CRASH
668 #define CRASH do { fprintf(stderr, "!! Forcing immediate crash a-la abort !!\n"); *((int *)0) = 0; } while(0)
669 #else
670 #define CRASH do { } while(0)
671 #endif
672
673 #define CHECK_BLOCKING(c) {      \
674                                                         if ((c)->blocking) {\
675                                                                 ast_log(LOG_WARNING, "Thread %ld Blocking '%s', already blocked by thread %ld in procedure %s\n", pthread_self(), (c)->name, (c)->blocker, (c)->blockproc); \
676                                                                 CRASH; \
677                                                         } else { \
678                                                                 (c)->blocker = pthread_self(); \
679                                                                 (c)->blockproc = __PRETTY_FUNCTION__; \
680                                                                         c->blocking = -1; \
681                                                                         } }
682
683 #if defined(__cplusplus) || defined(c_plusplus)
684 }
685 #endif
686
687
688 #endif