Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals

channel.h

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- A telephony toolkit for Linux.
00003  *
00004  * General Asterisk channel definitions.
00005  * 
00006  * Copyright (C) 1999-2004, Digium, Inc.
00007  *
00008  * Mark Spencer <markster@digium.com>
00009  *
00010  * This program is free software, distributed under the terms of
00011  * the GNU General Public License
00012  */
00013 
00014 #ifndef _ASTERISK_CHANNEL_H
00015 #define _ASTERISK_CHANNEL_H
00016 
00017 #include <asterisk/frame.h>
00018 #include <asterisk/sched.h>
00019 #include <asterisk/chanvars.h>
00020 #include <unistd.h>
00021 #include <setjmp.h>
00022 #if defined(__APPLE__)
00023 #include <asterisk/poll-compat.h>
00024 #else
00025 #include <sys/poll.h>
00026 #endif
00027 
00028 #if defined(__cplusplus) || defined(c_plusplus)
00029 extern "C" {
00030 #endif
00031 
00032 #include <asterisk/lock.h>
00033 
00034 //! Max length of an extension
00035 #define AST_MAX_EXTENSION 80
00036 
00037 //! Max length of the uniqueid
00038 #define AST_MAX_UNIQUEID 64
00039 
00040 #include <asterisk/cdr.h>
00041 #include <asterisk/monitor.h>
00042 
00043 
00044 #define AST_CHANNEL_NAME 80
00045 #define AST_CHANNEL_MAX_STACK 32
00046 
00047 #define MAX_LANGUAGE 20
00048 
00049 
00050 #define AST_MAX_FDS 8
00051 
00052 struct ast_generator {
00053    void *(*alloc)(struct ast_channel *chan, void *params);
00054    void (*release)(struct ast_channel *chan, void *data);
00055    int (*generate)(struct ast_channel *chan, void *data, int len, int samples);
00056 };
00057 
00058 //! Main Channel structure associated with a channel.
00059 /*! 
00060  * This is the side of it mostly used by the pbx and call management.
00061  */
00062 struct ast_channel {
00063    /*! ASCII Description of channel name */
00064    char name[AST_CHANNEL_NAME];     
00065    /*! Language requested */
00066    char language[MAX_LANGUAGE];     
00067    /*! Type of channel */
00068    char *type;          
00069    /*! File descriptor for channel -- Drivers will poll on these file descriptors, so at least one must be non -1.  */
00070    int fds[AST_MAX_FDS];         
00071 
00072    /*! Default music class */
00073    char musicclass[MAX_LANGUAGE];
00074 
00075    /*! Current generator data if there is any */
00076    void *generatordata;
00077    /*! Current active data generator */
00078    struct ast_generator *generator;
00079    /*! Whether or not the generator should be interrupted by write */
00080    int writeinterrupt;
00081 
00082    /*! Who are we bridged to, if we're bridged */
00083    struct ast_channel *bridge;
00084    /*! Who did we call? */
00085    struct ast_channel *dialed;
00086    /*! Who called us? */
00087    struct ast_channel *dialing;
00088    /*! Reverse the dialed link (0 false, 1 true) */
00089    int reversedialed;
00090    /*! Channel that will masquerade as us */
00091    struct ast_channel *masq;     
00092    /*! Who we are masquerading as */
00093    struct ast_channel *masqr;    
00094    /*! Call Detail Record Flags */
00095    int cdrflags;                                
00096    /*! Whether or not we're blocking */
00097    int blocking;           
00098    /*! Whether or not we have been hung up...  Do not set this value
00099        directly, use ast_softhangup */
00100    int _softhangup;           
00101    /*! Non-zero if this is a zombie channel */
00102    int zombie;             
00103    /*! Non-zero, set to actual time when channel is to be hung up */
00104    time_t   whentohangup;
00105    /*! If anyone is blocking, this is them */
00106    pthread_t blocker;         
00107    /*! Lock, can be used to lock a channel for some operations */
00108    ast_mutex_t lock;       
00109    /*! Procedure causing blocking */
00110    const char *blockproc;        
00111 
00112    /*! Current application */
00113    char *appl;          
00114    /*! Data passed to current application */
00115    char *data;          
00116    
00117    /*! Has an exception been detected */
00118    int exception;          
00119    /*! Which fd had an event detected on */
00120    int fdno;            
00121    /*! Schedule context */
00122    struct sched_context *sched;     
00123    /*! For streaming playback, the schedule ID */
00124    int streamid;           
00125    /*! Stream itself. */
00126    struct ast_filestream *stream;      
00127    /*! For streaming playback, the schedule ID */
00128    int vstreamid;          
00129    /*! Stream itself. */
00130    struct ast_filestream *vstream;     
00131    /*! Original writer format */
00132    int oldwriteformat;        
00133    
00134    /*! Timing fd */
00135    int timingfd;
00136    int (*timingfunc)(void *data);
00137    void *timingdata;
00138 
00139    /*! State of line -- Don't write directly, use ast_setstate */
00140    int _state;          
00141    /*! Number of rings so far */
00142    int rings;           
00143    /*! Current level of application */
00144    int stack;
00145 
00146 
00147    /*! Kinds of data this channel can natively handle */
00148    int nativeformats;         
00149    /*! Requested read format */
00150    int readformat;            
00151    /*! Requested write format */
00152    int writeformat;        
00153 
00154    
00155    /*! Malloc'd Dialed Number Identifier */
00156    char *dnid;          
00157    /*! Malloc'd Caller ID */
00158    char *callerid;
00159    /*! Malloc'd ANI */
00160    char *ani;        
00161    /*! Malloc'd RDNIS */
00162    char *rdnis;
00163    /*! Hide callerid from user */
00164    int restrictcid;
00165    /*! Callerid presentation/screening */
00166    int callingpres;
00167 
00168    
00169    /*! Current extension context */
00170    char context[AST_MAX_EXTENSION]; 
00171    /*! Current non-macro context */
00172    char macrocontext[AST_MAX_EXTENSION];  
00173    /*! Current non-macro extension */
00174    char macroexten[AST_MAX_EXTENSION];
00175    /*! Current non-macro priority */
00176    int macropriority;
00177    /*! Current extension number */
00178    char exten[AST_MAX_EXTENSION];      
00179    /* Current extension priority */
00180    int priority;                 
00181    /*! Application information -- see assigned numbers */
00182    void *app[AST_CHANNEL_MAX_STACK];   
00183    /*! Any/all queued DTMF characters */
00184    char dtmfq[AST_MAX_EXTENSION];      
00185    /*! Are DTMF digits being deferred */
00186    int deferdtmf;          
00187    /*! DTMF frame */
00188    struct ast_frame dtmff;       
00189    /*! Private channel implementation details */
00190    struct ast_channel_pvt *pvt;
00191 
00192                   
00193    /*! Jump buffer used for returning from applications */
00194    jmp_buf jmp[AST_CHANNEL_MAX_STACK]; 
00195 
00196    struct ast_pbx *pbx;
00197    /*! Set BEFORE PBX is started to determine AMA flags */
00198    int   amaflags;         
00199    /*! Account code for billing */
00200    char  accountcode[20];     
00201    /*! Call Detail Record */
00202    struct ast_cdr *cdr;       
00203    /*! Whether or not ADSI is detected on CPE */
00204    int   adsicpe;
00205    /*! Where to forward to if asked to dial on this interface */
00206    char call_forward[AST_MAX_EXTENSION];
00207 
00208    /*! Tone zone */
00209    struct tone_zone *zone;
00210 
00211    /* Channel monitoring */
00212    struct ast_channel_monitor *monitor;
00213 
00214    /*! Track the read/written samples for monitor use */
00215    unsigned long insmpl;
00216    unsigned long outsmpl;
00217 
00218    /* Frames in/out counters */
00219    unsigned int fin;
00220    unsigned int fout;
00221 
00222    /* Unique Channel Identifier */
00223    char uniqueid[AST_MAX_UNIQUEID];
00224 
00225    /* Why is the channel hanged up */
00226    int hangupcause;
00227    
00228    /* A linked list for variables */
00229    struct ast_var_t *vars; 
00230    AST_LIST_HEAD(varshead,ast_var_t) varshead;
00231 
00232    unsigned int callgroup;
00233    unsigned int pickupgroup;
00234 
00235    /*! channel flags of AST_FLAG_ type */
00236    int flag;
00237    
00238    /*! For easy linking */
00239    struct ast_channel *next;
00240 
00241 };
00242 
00243 #define AST_FLAG_DIGITAL   1  /* if the call is a digital ISDN call */
00244 
00245 static inline int ast_test_flag(struct ast_channel *chan, int mode)
00246 {
00247    return chan->flag & mode;
00248 }
00249 
00250 static inline void ast_set_flag(struct ast_channel *chan, int mode)
00251 {
00252    chan->flag |= mode;
00253 }
00254 
00255 static inline void ast_clear_flag(struct ast_channel *chan, int mode)
00256 {
00257    chan->flag &= ~mode;
00258 }
00259 
00260 static inline void ast_set2_flag(struct ast_channel *chan, int value, int mode)
00261 {
00262    if (value)
00263       ast_set_flag(chan, mode);
00264    else
00265       ast_clear_flag(chan, mode);
00266 }
00267 
00268 static inline void ast_dup_flag(struct ast_channel *dstchan, struct ast_channel *srcchan, int mode)
00269 {
00270    if (ast_test_flag(srcchan, mode))
00271       ast_set_flag(dstchan, mode);
00272    else
00273       ast_clear_flag(dstchan, mode);
00274 }  
00275 
00276 struct ast_bridge_config {
00277    int play_to_caller;
00278    int play_to_callee;
00279    int allowredirect_in;
00280    int allowredirect_out;
00281    int allowdisconnect_in;
00282    int allowdisconnect_out;
00283    long timelimit;
00284    long play_warning;
00285    long warning_freq;
00286    char *warning_sound;
00287    char *end_sound;
00288    char *start_sound;
00289    int firstpass;
00290 };
00291 
00292 struct chanmon;
00293 
00294 #define LOAD_OH(oh) {   \
00295    oh.context = context; \
00296    oh.exten = exten; \
00297    oh.priority = priority; \
00298    oh.callerid = callerid; \
00299    oh.variable = variable; \
00300    oh.account = account; \
00301 } 
00302 
00303 struct outgoing_helper {
00304    char *context;
00305    char *exten;
00306    int priority;
00307    char *callerid;
00308    char *variable;
00309    char *account;
00310 };
00311 
00312 #define AST_CDR_TRANSFER   (1 << 0)
00313 #define AST_CDR_FORWARD    (1 << 1)
00314 #define AST_CDR_CALLWAIT   (1 << 2)
00315 #define AST_CDR_CONFERENCE (1 << 3)
00316 
00317 #define AST_ADSI_UNKNOWN   (0)
00318 #define AST_ADSI_AVAILABLE (1)
00319 #define AST_ADSI_UNAVAILABLE  (2)
00320 #define AST_ADSI_OFFHOOKONLY  (3)
00321 
00322 #define AST_SOFTHANGUP_DEV       (1 << 0) /* Soft hangup by device */
00323 #define AST_SOFTHANGUP_ASYNCGOTO (1 << 1) /* Soft hangup for async goto */
00324 #define AST_SOFTHANGUP_SHUTDOWN     (1 << 2)
00325 #define AST_SOFTHANGUP_TIMEOUT      (1 << 3)
00326 #define AST_SOFTHANGUP_APPUNLOAD (1 << 4)
00327 #define AST_SOFTHANGUP_EXPLICIT     (1 << 5)
00328 
00329 /* Bits 0-15 of state are reserved for the state (up/down) of the line */
00330 /*! Channel is down and available */
00331 #define AST_STATE_DOWN     0     
00332 /*! Channel is down, but reserved */
00333 #define AST_STATE_RESERVED 1     
00334 /*! Channel is off hook */
00335 #define AST_STATE_OFFHOOK  2     
00336 /*! Digits (or equivalent) have been dialed */
00337 #define AST_STATE_DIALING  3     
00338 /*! Line is ringing */
00339 #define AST_STATE_RING     4     
00340 /*! Remote end is ringing */
00341 #define AST_STATE_RINGING  5     
00342 /*! Line is up */
00343 #define AST_STATE_UP    6     
00344 /*! Line is busy */
00345 #define AST_STATE_BUSY     7     
00346 /*! Digits (or equivalent) have been dialed while offhook */
00347 #define AST_STATE_DIALING_OFFHOOK   8
00348 /*! Channel has detected an incoming call and is waiting for ring */
00349 #define AST_STATE_PRERING       9
00350 
00351 /* Bits 16-32 of state are reserved for flags */
00352 /*! Do not transmit voice data */
00353 #define AST_STATE_MUTE     (1 << 16)   
00354 
00355 /*! Device is valid but channel didn't know state */
00356 #define AST_DEVICE_UNKNOWN 0
00357 /*! Device is not used */
00358 #define AST_DEVICE_NOT_INUSE  1
00359 /*! Device is in use */
00360 #define AST_DEVICE_INUSE   2
00361 /*! Device is busy */
00362 #define AST_DEVICE_BUSY    3
00363 /*! Device is invalid */
00364 #define AST_DEVICE_INVALID 4
00365 /*! Device is unavailable */
00366 #define AST_DEVICE_UNAVAILABLE   5
00367 /*! Device is ringing */
00368 #define AST_DEVICE_RINGING    6
00369 
00370 //! Requests a channel
00371 /*! 
00372  * \param type type of channel to request
00373  * \param format requested channel format
00374  * \param data data to pass to the channel requester
00375  * Request a channel of a given type, with data as optional information used 
00376  * by the low level module
00377  * Returns an ast_channel on success, NULL on failure.
00378  */
00379 struct ast_channel *ast_request(char *type, int format, void *data, char *uniqueid);
00380 
00381 //! Search the Channels by Name
00382 /*!
00383  * \param device like a dialstring
00384  * Search the Device in active channels by compare the channelname against 
00385  * the devicename. Compared are only the first chars to the first '-' char.
00386  * Returns an AST_DEVICE_UNKNOWN if no channel found or
00387  * AST_DEVICE_INUSE if a channel is found
00388  */
00389 int ast_parse_device_state(char *device);
00390 
00391 //! Asks a channel for device state
00392 /*!
00393  * \param device like a dialstring
00394  * Asks a channel for device state, data is  normaly a number from dialstring
00395  * used by the low level module
00396  * Trys the channel devicestate callback if not supported search in the
00397  * active channels list for the device.
00398  * Returns an AST_DEVICE_??? state -1 on failure
00399  */
00400 int ast_device_state(char *device);
00401 
00402 /*!
00403  * \param type type of channel to request
00404  * \param format requested channel format
00405  * \param data data to pass to the channel requester
00406  * \param timeout maximum amount of time to wait for an answer
00407  * \param why unsuccessful (if unsuceessful)
00408  * Request a channel of a given type, with data as optional information used 
00409  * by the low level module and attempt to place a call on it
00410  * Returns an ast_channel on success or no answer, NULL on failure.  Check the value of chan->_state
00411  * to know if the call was answered or not.
00412  */
00413 struct ast_channel *ast_request_and_dial(char *type, int format, void *data, int timeout, int *reason, int callingpres, char *callerid, char *uniqueid);
00414 
00415 struct ast_channel *__ast_request_and_dial(char *type, int format, void *data, int timeout, int *reason, int callingpres, char *callerid, struct outgoing_helper *oh, char *uniqueid);
00416 
00417 //! Registers a channel
00418 /*! 
00419  * \param type type of channel you are registering
00420  * \param description short description of the channel
00421  * \param capabilities a bit mask of the capabilities of the channel
00422  * \param requester a function pointer that properly responds to a call.  See one of the channel drivers for details.
00423  * Called by a channel module to register the kind of channels it supports.
00424  * It supplies a brief type, a longer, but still short description, and a
00425  * routine that creates a channel
00426  * Returns 0 on success, -1 on failure.
00427  */
00428 int ast_channel_register(char *type, char *description, int capabilities, 
00429          struct ast_channel* (*requester)(char *type, int format, void *data));
00430 
00431 /* Same like the upper function but with support for devicestate */
00432 int ast_channel_register_ex(char *type, char *description, int capabilities,
00433       struct ast_channel *(*requester)(char *type, int format, void *data),
00434       int (*devicestate)(void *data));
00435 
00436 //! Unregister a channel class
00437 /*
00438  * \param type the character string that corresponds to the channel you wish to unregister
00439  * Basically just unregisters the channel with the asterisk channel system
00440  * No return value.
00441  */
00442 void ast_channel_unregister(char *type);
00443 
00444 //! Hang up a channel 
00445 /*! 
00446  * \param chan channel to hang up
00447  * This function performs a hard hangup on a channel.  Unlike the soft-hangup, this function
00448  * performs all stream stopping, etc, on the channel that needs to end.
00449  * chan is no longer valid after this call.
00450  * Returns 0 on success, -1 on failure.
00451  */
00452 int ast_hangup(struct ast_channel *chan);
00453 
00454 //! Softly hangup up a channel
00455 /*! 
00456  * \param chan channel to be soft-hung-up
00457  * Call the protocol layer, but don't destroy the channel structure (use this if you are trying to
00458  * safely hangup a channel managed by another thread.
00459  * Returns 0 regardless
00460  */
00461 int ast_softhangup(struct ast_channel *chan, int cause);
00462 int ast_softhangup_nolock(struct ast_channel *chan, int cause);
00463 
00464 //! Check to see if a channel is needing hang up
00465 /*! 
00466  * \param chan channel on which to check for hang up
00467  * This function determines if the channel is being requested to be hung up.
00468  * Returns 0 if not, or 1 if hang up is requested (including time-out).
00469  */
00470 int ast_check_hangup(struct ast_channel *chan);
00471 
00472 //! Set when to hang a channel up
00473 /*! 
00474  * \param chan channel on which to check for hang up
00475  * \param offset offset in seconds from current time of when to hang up
00476  * This function sets the absolute time out on a channel (when to hang up).
00477  */
00478 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset);
00479 
00480 //! Answer a ringing call
00481 /*!
00482  * \param chan channel to answer
00483  * This function answers a channel and handles all necessary call
00484  * setup functions.
00485  * Returns 0 on success, -1 on failure
00486  */
00487 int ast_answer(struct ast_channel *chan);
00488 
00489 //! Make a call
00490 /*! 
00491  * \param chan which channel to make the call on
00492  * \param addr destination of the call
00493  * \param timeout time to wait on for connect
00494  * Place a call, take no longer than timeout ms.  Returns -1 on failure, 
00495    0 on not enough time (does not auto matically stop ringing), and  
00496    the number of seconds the connect took otherwise.
00497    Returns 0 on success, -1 on failure
00498    */
00499 int ast_call(struct ast_channel *chan, char *addr, int timeout);
00500 
00501 //! Indicates condition of channel
00502 /*! 
00503  * \param chan channel to change the indication
00504  * \param condition which condition to indicate on the channel
00505  * Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel
00506  * Returns 0 on success, -1 on failure
00507  */
00508 int ast_indicate(struct ast_channel *chan, int condition);
00509 
00510 /* Misc stuff */
00511 
00512 //! Wait for input on a channel
00513 /*! 
00514  * \param chan channel to wait on
00515  * \param ms length of time to wait on the channel
00516  * Wait for input on a channel for a given # of milliseconds (<0 for indefinite). 
00517   Returns < 0 on  failure, 0 if nothing ever arrived, and the # of ms remaining otherwise */
00518 int ast_waitfor(struct ast_channel *chan, int ms);
00519 
00520 //! Wait for a specied amount of time, looking for hangups
00521 /*!
00522  * \param chan channel to wait for
00523  * \param ms length of time in milliseconds to sleep
00524  * Waits for a specified amount of time, servicing the channel as required.
00525  * returns -1 on hangup, otherwise 0.
00526  */
00527 int ast_safe_sleep(struct ast_channel *chan, int ms);
00528 
00529 //! Wait for a specied amount of time, looking for hangups and a condition argument
00530 /*!
00531  * \param chan channel to wait for
00532  * \param ms length of time in milliseconds to sleep
00533  * \param cond a function pointer for testing continue condition
00534  * \param data argument to be passed to the condition test function
00535  * Waits for a specified amount of time, servicing the channel as required. If cond
00536  * returns 0, this function returns.
00537  * returns -1 on hangup, otherwise 0.
00538  */
00539 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data );
00540 
00541 //! Waits for activity on a group of channels
00542 /*! 
00543  * \param chan an array of pointers to channels
00544  * \param n number of channels that are to be waited upon
00545  * \param fds an array of fds to wait upon
00546  * \param nfds the number of fds to wait upon
00547  * \param exception exception flag
00548  * \param outfd fd that had activity on it
00549  * \param ms how long the wait was
00550  * Big momma function here.  Wait for activity on any of the n channels, or any of the nfds
00551    file descriptors.  Returns the channel with activity, or NULL on error or if an FD
00552    came first.  If the FD came first, it will be returned in outfd, otherwise, outfd
00553    will be -1 */
00554 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **chan, int n, int *fds, int nfds, int *exception, int *outfd, int *ms);
00555 
00556 //! Waits for input on a group of channels
00557 /*! Wait for input on an array of channels for a given # of milliseconds. Return channel
00558    with activity, or NULL if none has activity.  time "ms" is modified in-place, if applicable */
00559 struct ast_channel *ast_waitfor_n(struct ast_channel **chan, int n, int *ms);
00560 
00561 //! Waits for input on an fd
00562 /*! This version works on fd's only.  Be careful with it. */
00563 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception);
00564 
00565 
00566 //! Reads a frame
00567 /*!
00568  * \param chan channel to read a frame from
00569  * Read a frame.  Returns a frame, or NULL on error.  If it returns NULL, you
00570    best just stop reading frames and assume the channel has been
00571    disconnected. */
00572 struct ast_frame *ast_read(struct ast_channel *chan);
00573 
00574 //! Write a frame to a channel
00575 /*!
00576  * \param chan destination channel of the frame
00577  * \param frame frame that will be written
00578  * This function writes the given frame to the indicated channel.
00579  * It returns 0 on success, -1 on failure.
00580  */
00581 int ast_write(struct ast_channel *chan, struct ast_frame *frame);
00582 
00583 //! Write video frame to a channel
00584 /*!
00585  * \param chan destination channel of the frame
00586  * \param frame frame that will be written
00587  * This function writes the given frame to the indicated channel.
00588  * It returns 1 on success, 0 if not implemented, and -1 on failure.
00589  */
00590 int ast_write_video(struct ast_channel *chan, struct ast_frame *frame);
00591 
00592 /* Send empty audio to prime a channel driver */
00593 int ast_prod(struct ast_channel *chan);
00594 
00595 //! Sets read format on channel chan
00596 /*! 
00597  * \param chan channel to change
00598  * \param format format to change to
00599  * Set read format for channel to whichever component of "format" is best. 
00600  * Returns 0 on success, -1 on failure
00601  */
00602 int ast_set_read_format(struct ast_channel *chan, int format);
00603 
00604 //! Sets write format on channel chan
00605 /*! 
00606  * \param chan channel to change
00607  * \param format new format for writing
00608  * Set write format for channel to whichever compoent of "format" is best. 
00609  * Returns 0 on success, -1 on failure
00610  */
00611 int ast_set_write_format(struct ast_channel *chan, int format);
00612 
00613 //! Sends text to a channel
00614 /*! 
00615  * \param chan channel to act upon
00616  * \param text string of text to send on the channel
00617  * Write text to a display on a channel
00618  * Returns 0 on success, -1 on failure
00619  */
00620 int ast_sendtext(struct ast_channel *chan, char *text);
00621 
00622 //! Receives a text character from a channel
00623 /*! 
00624  * \param chan channel to act upon
00625  * \param timeout timeout in milliseconds (0 for infinite wait)
00626  * Read a char of text from a channel
00627  * Returns 0 on success, -1 on failure
00628  */
00629 
00630 int ast_senddigit(struct ast_channel *chan, char digit);
00631 
00632 int ast_recvchar(struct ast_channel *chan, int timeout);
00633 
00634 //! Browse channels in use
00635 /*! 
00636  * \param prev where you want to start in the channel list
00637  * Browse the channels currently in use 
00638  * Returns the next channel in the list, NULL on end.
00639  * If it returns a channel, that channel *has been locked*!
00640  */
00641 struct ast_channel *ast_channel_walk_locked(struct ast_channel *prev);
00642 
00643 //! Get channel by name (locks channel)
00644 struct ast_channel *ast_get_channel_by_name_locked(char *channame);
00645 
00646 //! Get channel by uniqueid (locks channel)
00647 struct ast_channel *ast_get_channel_by_uniqueid_locked(char *uniqueid);
00648 
00649 //! Waits for a digit
00650 /*! 
00651  * \param c channel to wait for a digit on
00652  * \param ms how many milliseconds to wait
00653  * Wait for a digit.  Returns <0 on error, 0 on no entry, and the digit on success. */
00654 char ast_waitfordigit(struct ast_channel *c, int ms);
00655 
00656 /* Same as above with audio fd for outputing read audio and ctrlfd to monitor for
00657    reading. Returns 1 if ctrlfd becomes available */
00658 char ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int ctrlfd);
00659 
00660 //! Reads multiple digits
00661 /*! 
00662  * \param c channel to read from
00663  * \param s string to read in to.  Must be at least the size of your length
00664  * \param len how many digits to read (maximum)
00665  * \param timeout how long to timeout between digits
00666  * \param rtimeout timeout to wait on the first digit
00667  * \param enders digits to end the string
00668  * Read in a digit string "s", max length "len", maximum timeout between 
00669    digits "timeout" (-1 for none), terminated by anything in "enders".  Give them rtimeout
00670    for the first digit.  Returns 0 on normal return, or 1 on a timeout.  In the case of
00671    a timeout, any digits that were read before the timeout will still be available in s.  
00672    RETURNS 2 in full version when ctrlfd is available, NOT 1*/
00673 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders);
00674 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders, int audiofd, int ctrlfd);
00675 
00676 /*! Report DTMF on channel 0 */
00677 #define AST_BRIDGE_DTMF_CHANNEL_0      (1 << 0)    
00678 /*! Report DTMF on channel 1 */
00679 #define AST_BRIDGE_DTMF_CHANNEL_1      (1 << 1)    
00680 /*! Return all voice frames on channel 0 */
00681 #define AST_BRIDGE_REC_CHANNEL_0    (1 << 2)    
00682 /*! Return all voice frames on channel 1 */
00683 #define AST_BRIDGE_REC_CHANNEL_1    (1 << 3)    
00684 /*! Ignore all signal frames except NULL */
00685 #define AST_BRIDGE_IGNORE_SIGS         (1 << 4)    
00686 
00687 
00688 //! Makes two channel formats compatible
00689 /*! 
00690  * \param c0 first channel to make compatible
00691  * \param c1 other channel to make compatible
00692  * Set two channels to compatible formats -- call before ast_channel_bridge in general .  Returns 0 on success
00693    and -1 if it could not be done */
00694 int ast_channel_make_compatible(struct ast_channel *c0, struct ast_channel *c1);
00695 
00696 //! Bridge two channels together
00697 /*! 
00698  * \param c0 first channel to bridge
00699  * \param c1 second channel to bridge
00700  * \param flags for the channels
00701  * \param fo destination frame(?)
00702  * \param rc destination channel(?)
00703  * Bridge two channels (c0 and c1) together.  If an important frame occurs, we return that frame in
00704    *rf (remember, it could be NULL) and which channel (0 or 1) in rc */
00705 //int ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc);
00706 int ast_channel_bridge(struct ast_channel *c0,struct ast_channel *c1,struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc);
00707 
00708 //! Weird function made for call transfers
00709 /*! 
00710  * \param original channel to make a copy of
00711  * \param clone copy of the original channel
00712  * This is a very strange and freaky function used primarily for transfer.  Suppose that
00713    "original" and "clone" are two channels in random situations.  This function takes
00714    the guts out of "clone" and puts them into the "original" channel, then alerts the
00715    channel driver of the change, asking it to fixup any private information (like the
00716    p->owner pointer) that is affected by the change.  The physical layer of the original
00717    channel is hung up.  */
00718 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone);
00719 
00720 int ast_channel_masquerade_locked(struct ast_channel *original, struct ast_channel *clone);
00721 
00722 
00723 char *ast_alloc_uniqueid(void);
00724 
00725 //! Gives the string form of a given state
00726 /*! 
00727  * \param state state to get the name of
00728  * Give a name to a state 
00729  * Pretty self explanatory.
00730  * Returns the text form of the binary state given
00731  */
00732 char *ast_state2str(int state);
00733 
00734 /* Options: Some low-level drivers may implement "options" allowing fine tuning of the
00735    low level channel.  See frame.h for options.  Note that many channel drivers may support
00736    none or a subset of those features, and you should not count on this if you want your
00737    asterisk application to be portable.  They're mainly useful for tweaking performance */
00738 
00739 //! Sets an option on a channel
00740 /*! 
00741  * \param channel channel to set options on
00742  * \param option option to change
00743  * \param data data specific to option
00744  * \param datalen length of the data
00745  * \param block blocking or not
00746  * Set an option on a channel (see frame.h), optionally blocking awaiting the reply 
00747  * Returns 0 on success and -1 on failure
00748  */
00749 int ast_channel_setoption(struct ast_channel *channel, int option, void *data, int datalen, int block);
00750 
00751 //! Checks the value of an option
00752 /*! 
00753  * Query the value of an option, optionally blocking until a reply is received
00754  * Works similarly to setoption except only reads the options.
00755  */
00756 struct ast_frame *ast_channel_queryoption(struct ast_channel *channel, int option, void *data, int *datalen, int block);
00757 
00758 //! Checks for HTML support on a channel
00759 /*! Returns 0 if channel does not support HTML or non-zero if it does */
00760 int ast_channel_supports_html(struct ast_channel *channel);
00761 
00762 //! Sends HTML on given channel
00763 /*! Send HTML or URL on link.  Returns 0 on success or -1 on failure */
00764 int ast_channel_sendhtml(struct ast_channel *channel, int subclass, char *data, int datalen);
00765 
00766 //! Sends a URL on a given link
00767 /*! Send URL on link.  Returns 0 on success or -1 on failure */
00768 int ast_channel_sendurl(struct ast_channel *channel, char *url);
00769 
00770 //! Defers DTMF
00771 /*! Defer DTMF so that you only read things like hangups and audio.  Returns
00772    non-zero if channel was already DTMF-deferred or 0 if channel is just now
00773    being DTMF-deferred */
00774 int ast_channel_defer_dtmf(struct ast_channel *chan);
00775 
00776 //! Undeos a defer
00777 /*! Undo defer.  ast_read will return any dtmf characters that were queued */
00778 void ast_channel_undefer_dtmf(struct ast_channel *chan);
00779 
00780 /*! Initiate system shutdown -- prevents new channels from being allocated.
00781     If "hangup" is non-zero, all existing channels will receive soft
00782      hangups */
00783 void ast_begin_shutdown(int hangup);
00784 
00785 /*! Cancels an existing shutdown and returns to normal operation */
00786 void ast_cancel_shutdown(void);
00787 
00788 /*! Returns number of active/allocated channels */
00789 int ast_active_channels(void);
00790 
00791 /*! Returns non-zero if Asterisk is being shut down */
00792 int ast_shutting_down(void);
00793 
00794 /*! Activate a given generator */
00795 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params);
00796 
00797 /*! Deactive an active generator */
00798 void ast_deactivate_generator(struct ast_channel *chan);
00799 
00800 void ast_set_callerid(struct ast_channel *chan, char *callerid, int  anitoo);
00801 
00802 /*! Start a tone going */
00803 int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
00804 /*! Stop a tone from playing */
00805 void ast_tonepair_stop(struct ast_channel *chan);
00806 /*! Play a tone pair for a given amount of time */
00807 int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol);
00808 
00809 /*! Automatically service a channel for us... */
00810 int ast_autoservice_start(struct ast_channel *chan);
00811 
00812 /*! Stop servicing a channel for us...  Returns -1 on error or if channel has been hungup */
00813 int ast_autoservice_stop(struct ast_channel *chan);
00814 
00815 /* If built with zaptel optimizations, force a scheduled expiration on the
00816    timer fd, at which point we call the callback function / data */
00817 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data);
00818 
00819 /* Transfer a channel (if supported).  Returns -1 on error, 0 if not supported
00820    and 1 if supported and requested */
00821 int ast_transfer(struct ast_channel *chan, char *dest);
00822 
00823 int ast_do_masquerade(struct ast_channel *chan);
00824 
00825 /* Misc. functions below */
00826 
00827 /* Helper function for migrating select to poll */
00828 static inline int ast_fdisset(struct pollfd *pfds, int fd, int max, int *start)
00829 {
00830    int x;
00831    for (x=start ? *start : 0;x<max;x++)
00832       if (pfds[x].fd == fd) {
00833          if (start) {
00834             if (x==*start)
00835                (*start)++;
00836          }
00837          return pfds[x].revents;
00838       }
00839    return 0;
00840 }
00841 
00842 //! Waits for activity on a group of channels
00843 /*! 
00844  * \param nfds the maximum number of file descriptors in the sets
00845  * \param rfds file descriptors to check for read availability
00846  * \param wfds file descriptors to check for write availability
00847  * \param efds file descriptors to check for exceptions (OOB data)
00848  * \param tvp timeout while waiting for events
00849  * This is the same as a standard select(), except it guarantees the
00850  * behaviour where the passed struct timeval is updated with how much
00851  * time was not slept while waiting for the specified events
00852  */
00853 static inline int ast_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tvp)
00854 {
00855 #ifdef __linux__
00856    return select(nfds, rfds, wfds, efds, tvp);
00857 #else
00858    if (tvp) {
00859       struct timeval tv, tvstart, tvend, tvlen;
00860       int res;
00861 
00862       tv = *tvp;
00863       gettimeofday(&tvstart, NULL);
00864       res = select(nfds, rfds, wfds, efds, tvp);
00865       gettimeofday(&tvend, NULL);
00866       timersub(&tvend, &tvstart, &tvlen);
00867       timersub(&tv, &tvlen, tvp);
00868       if (tvp->tv_sec < 0 || (tvp->tv_sec == 0 && tvp->tv_usec < 0)) {
00869          tvp->tv_sec = 0;
00870          tvp->tv_usec = 0;
00871       }
00872       return res;
00873    }
00874    else
00875       return select(nfds, rfds, wfds, efds, NULL);
00876 #endif
00877 }
00878 
00879 #if !defined(ast_strdupa) && defined(__GNUC__)
00880 # define ast_strdupa(s)                         \
00881   (__extension__                             \
00882     ({                                       \
00883       __const char *__old = (s);                \
00884       size_t __len = strlen (__old) + 1;           \
00885       char *__new = (char *) __builtin_alloca (__len);   \
00886       (char *) memcpy (__new, __old, __len);       \
00887     }))
00888 #endif
00889 
00890 #ifdef DO_CRASH
00891 #define CRASH do { fprintf(stderr, "!! Forcing immediate crash a-la abort !!\n"); *((int *)0) = 0; } while(0)
00892 #else
00893 #define CRASH do { } while(0)
00894 #endif
00895 
00896 #define CHECK_BLOCKING(c) {    \
00897                      if ((c)->blocking) {\
00898                         ast_log(LOG_WARNING, "Thread %ld Blocking '%s', already blocked by thread %ld in procedure %s\n", (long) pthread_self(), (c)->name, (long) (c)->blocker, (c)->blockproc); \
00899                         CRASH; \
00900                      } else { \
00901                         (c)->blocker = pthread_self(); \
00902                         (c)->blockproc = __PRETTY_FUNCTION__; \
00903                            c->blocking = -1; \
00904                            } }
00905 
00906 extern unsigned int ast_get_group(char *s);
00907 
00908 #if defined(__cplusplus) || defined(c_plusplus)
00909 }
00910 #endif
00911 
00912 
00913 #endif

Generated on Sat Nov 25 19:09:33 2006 for Asterisk by  doxygen 1.4.2