Use zaptel timers to wake up processes
[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         /*! Timing fd */
117         int timingfd;
118
119
120         /*! State of line -- Don't write directly, use ast_setstate */
121         int _state;                             
122         /*! Number of rings so far */
123         int rings;                              
124         /*! Current level of application */
125         int stack;                              
126
127
128         /*! Kinds of data this channel can natively handle */
129         int nativeformats;                      
130         /*! Requested read format */
131         int readformat;                         
132         /*! Requested write format */
133         int writeformat;                        
134
135         
136         /*! Malloc'd Dialed Number Identifier */
137         char *dnid;                             
138         /*! Malloc'd Caller ID */
139         char *callerid;                         
140         /*! Malloc'd ANI */
141         char *ani;                      
142         /*! Malloc'd RDNIS */
143         char *rdnis;
144
145         
146         /*! Current extension context */
147         char context[AST_MAX_EXTENSION];        
148         /*! Current non-macro context */
149         char macrocontext[AST_MAX_EXTENSION];   
150         /*! Current extension number */
151         char exten[AST_MAX_EXTENSION];          
152         /* Current extension priority */
153         int priority;                                           
154         /*! Application information -- see assigned numbers */
155         void *app[AST_CHANNEL_MAX_STACK];       
156         /*! Any/all queued DTMF characters */
157         char dtmfq[AST_MAX_EXTENSION];          
158         /*! Are DTMF digits being deferred */
159         int deferdtmf;                          
160         /*! DTMF frame */
161         struct ast_frame dtmff;                 
162         /*! Private channel implementation details */
163         struct ast_channel_pvt *pvt;
164
165                                                 
166         /*! Jump buffer used for returning from applications */
167         jmp_buf jmp[AST_CHANNEL_MAX_STACK];     
168
169         struct ast_pbx *pbx;
170         /*! Set BEFORE PBX is started to determine AMA flags */
171         int     amaflags;                       
172         /*! Account code for billing */
173         char    accountcode[20];                
174         /*! Call Detail Record */
175         struct ast_cdr *cdr;                    
176         /*! Whether or not ADSI is detected on CPE */
177         int     adsicpe;
178         /*! Where to forward to if asked to dial on this interface */
179         char call_forward[AST_MAX_EXTENSION];
180
181         /*! Tone zone */
182         struct tone_zone *zone;
183
184         /* Channel monitoring */
185         struct ast_channel_monitor *monitor;
186
187         /* Frames in/out counters */
188         unsigned int fin;
189         unsigned int fout;
190
191         /* A linked list for variables */
192         struct ast_var_t *vars; 
193         AST_LIST_HEAD(varshead,ast_var_t) varshead;
194
195         unsigned int callgroup;
196         unsigned int pickupgroup;
197         
198         /*! For easy linking */
199         struct ast_channel *next;               
200
201 };
202
203 struct chanmon;
204
205 #define AST_CDR_TRANSFER        (1 << 0)
206 #define AST_CDR_FORWARD         (1 << 1)
207 #define AST_CDR_CALLWAIT        (1 << 2)
208 #define AST_CDR_CONFERENCE      (1 << 3)
209
210 #define AST_ADSI_UNKNOWN        (0)
211 #define AST_ADSI_AVAILABLE      (1)
212 #define AST_ADSI_UNAVAILABLE    (2)
213 #define AST_ADSI_OFFHOOKONLY    (3)
214
215 #define AST_SOFTHANGUP_DEV                      (1 << 0)        /* Soft hangup by device */
216 #define AST_SOFTHANGUP_ASYNCGOTO        (1 << 1)        /* Soft hangup for async goto */
217 #define AST_SOFTHANGUP_SHUTDOWN         (1 << 2)
218 #define AST_SOFTHANGUP_TIMEOUT          (1 << 3)
219 #define AST_SOFTHANGUP_APPUNLOAD        (1 << 4)
220 #define AST_SOFTHANGUP_EXPLICIT         (1 << 5)
221
222 /* Bits 0-15 of state are reserved for the state (up/down) of the line */
223 /*! Channel is down and available */
224 #define AST_STATE_DOWN          0               
225 /*! Channel is down, but reserved */
226 #define AST_STATE_RESERVED      1               
227 /*! Channel is off hook */
228 #define AST_STATE_OFFHOOK       2               
229 /*! Digits (or equivalent) have been dialed */
230 #define AST_STATE_DIALING       3               
231 /*! Line is ringing */
232 #define AST_STATE_RING          4               
233 /*! Remote end is ringing */
234 #define AST_STATE_RINGING       5               
235 /*! Line is up */
236 #define AST_STATE_UP            6               
237 /*! Line is busy */
238 #define AST_STATE_BUSY          7               
239
240 /* Bits 16-32 of state are reserved for flags */
241 /*! Do not transmit voice data */
242 #define AST_STATE_MUTE          (1 << 16)       
243
244 /*! Device is valid but channel didn't know state */
245 #define AST_DEVICE_UNKNOWN      0
246 /*! Device is not used */
247 #define AST_DEVICE_NOT_INUSE    1
248 /*! Device is in use */
249 #define AST_DEVICE_INUSE        2
250 /*! Device is busy */
251 #define AST_DEVICE_BUSY         3
252 /*! Device is invalid */
253 #define AST_DEVICE_INVALID      4
254 /*! Device is unavailable */
255 #define AST_DEVICE_UNAVAILABLE  5
256
257 //! Requests a channel
258 /*! 
259  * \param type type of channel to request
260  * \param format requested channel format
261  * \param data data to pass to the channel requester
262  * Request a channel of a given type, with data as optional information used 
263  * by the low level module
264  * Returns an ast_channel on success, NULL on failure.
265  */
266 struct ast_channel *ast_request(char *type, int format, void *data);
267
268 //! Search the Channels by Name
269 /*!
270  * \param device like a dialstring
271  * Search the Device in active channels by compare the channelname against 
272  * the devicename. Compared are only the first chars to the first '-' char.
273  * Returns an AST_DEVICE_UNKNOWN if no channel found or
274  * AST_DEVICE_INUSE if a channel is found
275  */
276 int ast_parse_device_state(char *device);
277
278 //! Asks a channel for device state
279 /*!
280  * \param device like a dialstring
281  * Asks a channel for device state, data is  normaly a number from dialstring
282  * used by the low level module
283  * Trys the channel devicestate callback if not supported search in the
284  * active channels list for the device.
285  * Returns an AST_DEVICE_??? state -1 on failure
286  */
287 int ast_device_state(char *device);
288
289 /*!
290  * \param type type of channel to request
291  * \param format requested channel format
292  * \param data data to pass to the channel requester
293  * \param timeout maximum amount of time to wait for an answer
294  * \param why unsuccessful (if unsuceessful)
295  * Request a channel of a given type, with data as optional information used 
296  * by the low level module and attempt to place a call on it
297  * Returns an ast_channel on success or no answer, NULL on failure.  Check the value of chan->_state
298  * to know if the call was answered or not.
299  */
300 struct ast_channel *ast_request_and_dial(char *type, int format, void *data, int timeout, int *reason, char *callerid);
301
302 //! Registers a channel
303 /*! 
304  * \param type type of channel you are registering
305  * \param description short description of the channel
306  * \param capabilities a bit mask of the capabilities of the channel
307  * \param requester a function pointer that properly responds to a call.  See one of the channel drivers for details.
308  * Called by a channel module to register the kind of channels it supports.
309  * It supplies a brief type, a longer, but still short description, and a
310  * routine that creates a channel
311  * Returns 0 on success, -1 on failure.
312  */
313 int ast_channel_register(char *type, char *description, int capabilities, 
314                         struct ast_channel* (*requester)(char *type, int format, void *data));
315
316 /* Same like the upper function but with support for devicestate */
317 int ast_channel_register_ex(char *type, char *description, int capabilities,
318                 struct ast_channel *(*requester)(char *type, int format, void *data),
319                 int (*devicestate)(void *data));
320
321 //! Unregister a channel class
322 /*
323  * \param type the character string that corresponds to the channel you wish to unregister
324  * Basically just unregisters the channel with the asterisk channel system
325  * No return value.
326  */
327 void ast_channel_unregister(char *type);
328
329 //! Hang up a channel 
330 /*! 
331  * \param chan channel to hang up
332  * This function performs a hard hangup on a channel.  Unlike the soft-hangup, this function
333  * performs all stream stopping, etc, on the channel that needs to end.
334  * chan is no longer valid after this call.
335  * Returns 0 on success, -1 on failure.
336  */
337 int ast_hangup(struct ast_channel *chan);
338
339 //! Softly hangup up a channel
340 /*! 
341  * \param chan channel to be soft-hung-up
342  * Call the protocol layer, but don't destroy the channel structure (use this if you are trying to
343  * safely hangup a channel managed by another thread.
344  * Returns 0 regardless
345  */
346 int ast_softhangup(struct ast_channel *chan, int cause);
347 int ast_softhangup_nolock(struct ast_channel *chan, int cause);
348
349 //! Check to see if a channel is needing hang up
350 /*! 
351  * \param chan channel on which to check for hang up
352  * This function determines if the channel is being requested to be hung up.
353  * Returns 0 if not, or 1 if hang up is requested (including time-out).
354  */
355 int ast_check_hangup(struct ast_channel *chan);
356
357 //! Set when to hang a channel up
358 /*! 
359  * \param chan channel on which to check for hang up
360  * \param offset offset in seconds from current time of when to hang up
361  * This function sets the absolute time out on a channel (when to hang up).
362  */
363 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset);
364
365 //! Answer a ringing call
366 /*!
367  * \param chan channel to answer
368  * This function answers a channel and handles all necessary call
369  * setup functions.
370  * Returns 0 on success, -1 on failure
371  */
372 int ast_answer(struct ast_channel *chan);
373
374 //! Make a call
375 /*! 
376  * \param chan which channel to make the call on
377  * \param addr destination of the call
378  * \param timeout time to wait on for connect
379  * Place a call, take no longer than timeout ms.  Returns -1 on failure, 
380    0 on not enough time (does not auto matically stop ringing), and  
381    the number of seconds the connect took otherwise.
382    Returns 0 on success, -1 on failure
383    */
384 int ast_call(struct ast_channel *chan, char *addr, int timeout);
385
386 //! Indicates condition of channel
387 /*! 
388  * \param chan channel to change the indication
389  * \param condition which condition to indicate on the channel
390  * Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel
391  * Returns 0 on success, -1 on failure
392  */
393 int ast_indicate(struct ast_channel *chan, int condition);
394
395 /* Misc stuff */
396
397 //! Wait for input on a channel
398 /*! 
399  * \param chan channel to wait on
400  * \param ms length of time to wait on the channel
401  * Wait for input on a channel for a given # of milliseconds (<0 for indefinite). 
402   Returns < 0 on  failure, 0 if nothing ever arrived, and the # of ms remaining otherwise */
403 int ast_waitfor(struct ast_channel *chan, int ms);
404
405 //! Wait for a specied amount of time, looking for hangups
406 /*!
407  * \param chan channel to wait for
408  * \param ms length of time in milliseconds to sleep
409  * Waits for a specified amount of time, servicing the channel as required.
410  * returns -1 on hangup, otherwise 0.
411  */
412 int ast_safe_sleep(struct ast_channel *chan, int ms);
413
414 //! Wait for a specied amount of time, looking for hangups and a condition argument
415 /*!
416  * \param chan channel to wait for
417  * \param ms length of time in milliseconds to sleep
418  * \param cond a function pointer for testing continue condition
419  * \param data argument to be passed to the condition test function
420  * Waits for a specified amount of time, servicing the channel as required. If cond
421  * returns 0, this function returns.
422  * returns -1 on hangup, otherwise 0.
423  */
424 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data );
425
426 //! Waits for activity on a group of channels
427 /*! 
428  * \param chan an array of pointers to channels
429  * \param n number of channels that are to be waited upon
430  * \param fds an array of fds to wait upon
431  * \param nfds the number of fds to wait upon
432  * \param exception exception flag
433  * \param outfd fd that had activity on it
434  * \param ms how long the wait was
435  * Big momma function here.  Wait for activity on any of the n channels, or any of the nfds
436    file descriptors.  Returns the channel with activity, or NULL on error or if an FD
437    came first.  If the FD came first, it will be returned in outfd, otherwise, outfd
438    will be -1 */
439 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **chan, int n, int *fds, int nfds, int *exception, int *outfd, int *ms);
440
441 //! Waits for input on a group of channels
442 /*! Wait for input on an array of channels for a given # of milliseconds. Return channel
443    with activity, or NULL if none has activity.  time "ms" is modified in-place, if applicable */
444 struct ast_channel *ast_waitfor_n(struct ast_channel **chan, int n, int *ms);
445
446 //! Waits for input on an fd
447 /*! This version works on fd's only.  Be careful with it. */
448 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception);
449
450
451 //! Reads a frame
452 /*! 
453  * \param chan channel to read a frame from
454  * Read a frame.  Returns a frame, or NULL on error.  If it returns NULL, you
455    best just stop reading frames and assume the channel has been
456    disconnected. */
457 struct ast_frame *ast_read(struct ast_channel *chan);
458
459 //! Write a frame to a channel
460 /*!
461  * \param chan destination channel of the frame
462  * \param frame frame that will be written
463  * This function writes the given frame to the indicated channel.
464  * It returns 0 on success, -1 on failure.
465  */
466 int ast_write(struct ast_channel *chan, struct ast_frame *frame);
467
468 /* Send empty audio to prime a channel driver */
469 int ast_prod(struct ast_channel *chan);
470
471 //! Sets read format on channel chan
472 /*! 
473  * \param chan channel to change
474  * \param format format to change to
475  * Set read format for channel to whichever component of "format" is best. 
476  * Returns 0 on success, -1 on failure
477  */
478 int ast_set_read_format(struct ast_channel *chan, int format);
479
480 //! Sets write format on channel chan
481 /*! 
482  * \param chan channel to change
483  * \param format new format for writing
484  * Set write format for channel to whichever compoent of "format" is best. 
485  * Returns 0 on success, -1 on failure
486  */
487 int ast_set_write_format(struct ast_channel *chan, int format);
488
489 //! Sends text to a channel
490 /*! 
491  * \param chan channel to act upon
492  * \param text string of text to send on the channel
493  * Write text to a display on a channel
494  * Returns 0 on success, -1 on failure
495  */
496 int ast_sendtext(struct ast_channel *chan, char *text);
497
498 //! Receives a text character from a channel
499 /*! 
500  * \param chan channel to act upon
501  * \param timeout timeout in milliseconds (0 for infinite wait)
502  * Read a char of text from a channel
503  * Returns 0 on success, -1 on failure
504  */
505 int ast_recvchar(struct ast_channel *chan, int timeout);
506
507 //! Browse channels in use
508 /*! 
509  * \param prev where you want to start in the channel list
510  * Browse the channels currently in use 
511  * Returns the next channel in the list, NULL on end.
512  */
513 struct ast_channel *ast_channel_walk(struct ast_channel *prev);
514
515 //! Waits for a digit
516 /*! 
517  * \param c channel to wait for a digit on
518  * \param ms how many milliseconds to wait
519  * Wait for a digit.  Returns <0 on error, 0 on no entry, and the digit on success. */
520 char ast_waitfordigit(struct ast_channel *c, int ms);
521
522 /* Same as above with audio fd for outputing read audio and ctrlfd to monitor for
523    reading. Returns 1 if ctrlfd becomes available */
524 char ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int ctrlfd);
525
526 //! Reads multiple digits
527 /*! 
528  * \param c channel to read from
529  * \param s string to read in to.  Must be at least the size of your length
530  * \param len how many digits to read (maximum)
531  * \param timeout how long to timeout between digits
532  * \param rtimeout timeout to wait on the first digit
533  * \param enders digits to end the string
534  * Read in a digit string "s", max length "len", maximum timeout between 
535    digits "timeout" (-1 for none), terminated by anything in "enders".  Give them rtimeout
536    for the first digit.  Returns 0 on normal return, or 1 on a timeout.  In the case of
537    a timeout, any digits that were read before the timeout will still be available in s.  
538    RETURNS 2 in full version when ctrlfd is available, NOT 1*/
539 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders);
540 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders, int audiofd, int ctrlfd);
541
542 /*! Report DTMF on channel 0 */
543 #define AST_BRIDGE_DTMF_CHANNEL_0               (1 << 0)                
544 /*! Report DTMF on channel 1 */
545 #define AST_BRIDGE_DTMF_CHANNEL_1               (1 << 1)                
546 /*! Return all voice frames on channel 0 */
547 #define AST_BRIDGE_REC_CHANNEL_0                (1 << 2)                
548 /*! Return all voice frames on channel 1 */
549 #define AST_BRIDGE_REC_CHANNEL_1                (1 << 3)                
550 /*! Ignore all signal frames except NULL */
551 #define AST_BRIDGE_IGNORE_SIGS                  (1 << 4)                
552
553
554 //! Makes two channel formats compatible
555 /*! 
556  * \param c0 first channel to make compatible
557  * \param c1 other channel to make compatible
558  * Set two channels to compatible formats -- call before ast_channel_bridge in general .  Returns 0 on success
559    and -1 if it could not be done */
560 int ast_channel_make_compatible(struct ast_channel *c0, struct ast_channel *c1);
561
562 //! Bridge two channels together
563 /*! 
564  * \param c0 first channel to bridge
565  * \param c1 second channel to bridge
566  * \param flags for the channels
567  * \param fo destination frame(?)
568  * \param rc destination channel(?)
569  * Bridge two channels (c0 and c1) together.  If an important frame occurs, we return that frame in
570    *rf (remember, it could be NULL) and which channel (0 or 1) in rc */
571 int ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc);
572
573 //! Weird function made for call transfers
574 /*! 
575  * \param original channel to make a copy of
576  * \param clone copy of the original channel
577  * This is a very strange and freaky function used primarily for transfer.  Suppose that
578    "original" and "clone" are two channels in random situations.  This function takes
579    the guts out of "clone" and puts them into the "original" channel, then alerts the
580    channel driver of the change, asking it to fixup any private information (like the
581    p->owner pointer) that is affected by the change.  The physical layer of the original
582    channel is hung up.  */
583 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone);
584
585 //! Gives the string form of a given state
586 /*! 
587  * \param state state to get the name of
588  * Give a name to a state 
589  * Pretty self explanatory.
590  * Returns the text form of the binary state given
591  */
592 char *ast_state2str(int state);
593
594 /* Options: Some low-level drivers may implement "options" allowing fine tuning of the
595    low level channel.  See frame.h for options.  Note that many channel drivers may support
596    none or a subset of those features, and you should not count on this if you want your
597    asterisk application to be portable.  They're mainly useful for tweaking performance */
598
599 //! Sets an option on a channel
600 /*! 
601  * \param channel channel to set options on
602  * \param option option to change
603  * \param data data specific to option
604  * \param datalen length of the data
605  * \param block blocking or not
606  * Set an option on a channel (see frame.h), optionally blocking awaiting the reply 
607  * Returns 0 on success and -1 on failure
608  */
609 int ast_channel_setoption(struct ast_channel *channel, int option, void *data, int datalen, int block);
610
611 //! Checks the value of an option
612 /*! 
613  * Query the value of an option, optionally blocking until a reply is received
614  * Works similarly to setoption except only reads the options.
615  */
616 struct ast_frame *ast_channel_queryoption(struct ast_channel *channel, int option, void *data, int *datalen, int block);
617
618 //! Checks for HTML support on a channel
619 /*! Returns 0 if channel does not support HTML or non-zero if it does */
620 int ast_channel_supports_html(struct ast_channel *channel);
621
622 //! Sends HTML on given channel
623 /*! Send HTML or URL on link.  Returns 0 on success or -1 on failure */
624 int ast_channel_sendhtml(struct ast_channel *channel, int subclass, char *data, int datalen);
625
626 //! Sends a URL on a given link
627 /*! Send URL on link.  Returns 0 on success or -1 on failure */
628 int ast_channel_sendurl(struct ast_channel *channel, char *url);
629
630 //! Defers DTMF
631 /*! Defer DTMF so that you only read things like hangups and audio.  Returns
632    non-zero if channel was already DTMF-deferred or 0 if channel is just now
633    being DTMF-deferred */
634 int ast_channel_defer_dtmf(struct ast_channel *chan);
635
636 //! Undeos a defer
637 /*! Undo defer.  ast_read will return any dtmf characters that were queued */
638 void ast_channel_undefer_dtmf(struct ast_channel *chan);
639
640 /*! Initiate system shutdown -- prevents new channels from being allocated.
641     If "hangup" is non-zero, all existing channels will receive soft
642      hangups */
643 void ast_begin_shutdown(int hangup);
644
645 /*! Cancels an existing shutdown and returns to normal operation */
646 void ast_cancel_shutdown(void);
647
648 /*! Returns number of active/allocated channels */
649 int ast_active_channels(void);
650
651 /*! Returns non-zero if Asterisk is being shut down */
652 int ast_shutting_down(void);
653
654 /*! Activate a given generator */
655 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params);
656
657 /*! Deactive an active generator */
658 void ast_deactivate_generator(struct ast_channel *chan);
659
660 void ast_set_callerid(struct ast_channel *chan, char *callerid, int  anitoo);
661
662 /*! Start a tone going */
663 int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
664 /*! Stop a tone from playing */
665 void ast_tonepair_stop(struct ast_channel *chan);
666 /*! Play a tone pair for a given amount of time */
667 int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
668
669 /*! Automatically service a channel for us... */
670 int ast_autoservice_start(struct ast_channel *chan);
671
672 /*! Stop servicing a channel for us...  Returns -1 on error or if channel has been hungup */
673 int ast_autoservice_stop(struct ast_channel *chan);
674
675 /* If built with zaptel optimizations, force a scheduled expiration on the
676    timer fd */
677 int ast_settimeout(struct ast_channel *c, int ms);
678
679 /* Misc. functions below */
680
681 //! Waits for activity on a group of channels
682 /*! 
683  * \param nfds the maximum number of file descriptors in the sets
684  * \param rfds file descriptors to check for read availability
685  * \param wfds file descriptors to check for write availability
686  * \param efds file descriptors to check for exceptions (OOB data)
687  * \param tvp timeout while waiting for events
688  * This is the same as a standard select(), except it guarantees the
689  * behaviour where the passed struct timeval is updated with how much
690  * time was not slept while waiting for the specified events
691  */
692 static inline int ast_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tvp)
693 {
694 #ifdef __linux__
695         return select(nfds, rfds, wfds, efds, tvp);
696 #else
697         if (tvp) {
698                 struct timeval tv, tvstart, tvend, tvlen;
699                 int res;
700
701                 tv = *tvp;
702                 gettimeofday(&tvstart, NULL);
703                 res = select(nfds, rfds, wfds, efds, tvp);
704                 gettimeofday(&tvend, NULL);
705                 timersub(&tvend, &tvstart, &tvlen);
706                 timersub(&tv, &tvlen, tvp);
707                 if (tvp->tv_sec < 0 || (tvp->tv_sec == 0 && tvp->tv_usec < 0)) {
708                         tvp->tv_sec = 0;
709                         tvp->tv_usec = 0;
710                 }
711                 return res;
712         }
713         else
714                 return select(nfds, rfds, wfds, efds, NULL);
715 #endif
716 }
717
718 #if !defined(ast_strdupa) && defined(__GNUC__)
719 # define ast_strdupa(s)                                                                 \
720   (__extension__                                                                                \
721     ({                                                                                                  \
722       __const char *__old = (s);                                                \
723       size_t __len = strlen (__old) + 1;                                \
724       char *__new = (char *) __builtin_alloca (__len);  \
725       (char *) memcpy (__new, __old, __len);                    \
726     }))
727 #endif
728
729 #ifdef DO_CRASH
730 #define CRASH do { fprintf(stderr, "!! Forcing immediate crash a-la abort !!\n"); *((int *)0) = 0; } while(0)
731 #else
732 #define CRASH do { } while(0)
733 #endif
734
735 #define CHECK_BLOCKING(c) {      \
736                                                         if ((c)->blocking) {\
737                                                                 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); \
738                                                                 CRASH; \
739                                                         } else { \
740                                                                 (c)->blocker = pthread_self(); \
741                                                                 (c)->blockproc = __PRETTY_FUNCTION__; \
742                                                                         c->blocking = -1; \
743                                                                         } }
744
745 #if defined(__cplusplus) || defined(c_plusplus)
746 }
747 #endif
748
749
750 #endif