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