00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "asterisk.h"
00027
00028 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
00029
00030 #include <stdio.h>
00031 #include <stdlib.h>
00032 #include <stdarg.h>
00033 #include <string.h>
00034 #include <sys/time.h>
00035 #include <signal.h>
00036 #include <errno.h>
00037 #include <unistd.h>
00038 #include <math.h>
00039
00040 #ifdef HAVE_ZAPTEL
00041 #include <sys/ioctl.h>
00042 #include <zaptel/zaptel.h>
00043 #endif
00044
00045 #include "asterisk/pbx.h"
00046 #include "asterisk/frame.h"
00047 #include "asterisk/sched.h"
00048 #include "asterisk/options.h"
00049 #include "asterisk/channel.h"
00050 #include "asterisk/chanspy.h"
00051 #include "asterisk/musiconhold.h"
00052 #include "asterisk/logger.h"
00053 #include "asterisk/say.h"
00054 #include "asterisk/file.h"
00055 #include "asterisk/cli.h"
00056 #include "asterisk/translate.h"
00057 #include "asterisk/manager.h"
00058 #include "asterisk/chanvars.h"
00059 #include "asterisk/linkedlists.h"
00060 #include "asterisk/indications.h"
00061 #include "asterisk/monitor.h"
00062 #include "asterisk/causes.h"
00063 #include "asterisk/callerid.h"
00064 #include "asterisk/utils.h"
00065 #include "asterisk/lock.h"
00066 #include "asterisk/app.h"
00067 #include "asterisk/transcap.h"
00068 #include "asterisk/devicestate.h"
00069 #include "asterisk/sha1.h"
00070 #include "asterisk/threadstorage.h"
00071 #include "asterisk/slinfactory.h"
00072
00073 struct channel_spy_trans {
00074 int last_format;
00075 struct ast_trans_pvt *path;
00076 };
00077
00078 struct ast_channel_spy_list {
00079 struct channel_spy_trans read_translator;
00080 struct channel_spy_trans write_translator;
00081 AST_LIST_HEAD_NOLOCK(, ast_channel_spy) list;
00082 };
00083
00084 struct ast_channel_whisper_buffer {
00085 ast_mutex_t lock;
00086 struct ast_slinfactory sf;
00087 unsigned int original_format;
00088 struct ast_trans_pvt *path;
00089 };
00090
00091
00092 #define MONITOR_CONSTANT_DELAY
00093 #define MONITOR_DELAY 150 * 8
00094
00095
00096 static int shutting_down;
00097
00098 static int uniqueint;
00099
00100 unsigned long global_fin, global_fout;
00101
00102 AST_THREADSTORAGE(state2str_threadbuf, state2str_threadbuf_init);
00103 #define STATE2STR_BUFSIZE 32
00104
00105
00106
00107 #define AST_DEFAULT_EMULATE_DTMF_DURATION 100
00108
00109
00110 #define AST_MIN_DTMF_DURATION 80
00111
00112
00113
00114 #define AST_MIN_DTMF_GAP 45
00115
00116 struct chanlist {
00117 const struct ast_channel_tech *tech;
00118 AST_LIST_ENTRY(chanlist) list;
00119 };
00120
00121
00122 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
00123
00124
00125
00126 static AST_LIST_HEAD_STATIC(channels, ast_channel);
00127
00128
00129 const struct ast_cause {
00130 int cause;
00131 const char *name;
00132 const char *desc;
00133 } causes[] = {
00134 { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
00135 { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
00136 { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
00137 { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
00138 { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
00139 { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
00140 { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
00141 { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
00142 { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
00143 { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
00144 { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
00145 { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
00146 { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
00147 { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
00148 { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
00149 { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
00150 { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
00151 { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
00152 { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
00153 { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
00154 { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
00155 { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
00156 { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
00157 { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
00158 { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
00159 { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
00160 { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
00161 { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
00162 { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
00163 { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
00164 { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
00165 { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
00166 { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
00167 { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
00168 { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
00169 { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
00170 { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
00171 { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
00172 { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
00173 { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
00174 { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
00175 { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
00176 { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
00177 { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
00178 };
00179
00180 struct ast_variable *ast_channeltype_list(void)
00181 {
00182 struct chanlist *cl;
00183 struct ast_variable *var=NULL, *prev = NULL;
00184 AST_LIST_TRAVERSE(&backends, cl, list) {
00185 if (prev) {
00186 if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description)))
00187 prev = prev->next;
00188 } else {
00189 var = ast_variable_new(cl->tech->type, cl->tech->description);
00190 prev = var;
00191 }
00192 }
00193 return var;
00194 }
00195
00196 static int show_channeltypes(int fd, int argc, char *argv[])
00197 {
00198 #define FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n"
00199 struct chanlist *cl;
00200 int count_chan = 0;
00201
00202 ast_cli(fd, FORMAT, "Type", "Description", "Devicestate", "Indications", "Transfer");
00203 ast_cli(fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
00204 if (AST_LIST_LOCK(&channels)) {
00205 ast_log(LOG_WARNING, "Unable to lock channel list\n");
00206 return -1;
00207 }
00208 AST_LIST_TRAVERSE(&backends, cl, list) {
00209 ast_cli(fd, FORMAT, cl->tech->type, cl->tech->description,
00210 (cl->tech->devicestate) ? "yes" : "no",
00211 (cl->tech->indicate) ? "yes" : "no",
00212 (cl->tech->transfer) ? "yes" : "no");
00213 count_chan++;
00214 }
00215 AST_LIST_UNLOCK(&channels);
00216 ast_cli(fd, "----------\n%d channel drivers registered.\n", count_chan);
00217 return RESULT_SUCCESS;
00218
00219 #undef FORMAT
00220
00221 }
00222
00223 static int show_channeltype_deprecated(int fd, int argc, char *argv[])
00224 {
00225 struct chanlist *cl = NULL;
00226
00227 if (argc != 3)
00228 return RESULT_SHOWUSAGE;
00229
00230 if (AST_LIST_LOCK(&channels)) {
00231 ast_log(LOG_WARNING, "Unable to lock channel list\n");
00232 return RESULT_FAILURE;
00233 }
00234
00235 AST_LIST_TRAVERSE(&backends, cl, list) {
00236 if (!strncasecmp(cl->tech->type, argv[2], strlen(cl->tech->type))) {
00237 break;
00238 }
00239 }
00240
00241
00242 if (!cl) {
00243 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[2]);
00244 AST_LIST_UNLOCK(&channels);
00245 return RESULT_FAILURE;
00246 }
00247
00248 ast_cli(fd,
00249 "-- Info about channel driver: %s --\n"
00250 " Device State: %s\n"
00251 " Indication: %s\n"
00252 " Transfer : %s\n"
00253 " Capabilities: %d\n"
00254 " Digit Begin: %s\n"
00255 " Digit End: %s\n"
00256 " Send HTML : %s\n"
00257 " Image Support: %s\n"
00258 " Text Support: %s\n",
00259 cl->tech->type,
00260 (cl->tech->devicestate) ? "yes" : "no",
00261 (cl->tech->indicate) ? "yes" : "no",
00262 (cl->tech->transfer) ? "yes" : "no",
00263 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
00264 (cl->tech->send_digit_begin) ? "yes" : "no",
00265 (cl->tech->send_digit_end) ? "yes" : "no",
00266 (cl->tech->send_html) ? "yes" : "no",
00267 (cl->tech->send_image) ? "yes" : "no",
00268 (cl->tech->send_text) ? "yes" : "no"
00269
00270 );
00271
00272 AST_LIST_UNLOCK(&channels);
00273 return RESULT_SUCCESS;
00274 }
00275
00276 static int show_channeltype(int fd, int argc, char *argv[])
00277 {
00278 struct chanlist *cl = NULL;
00279
00280 if (argc != 4)
00281 return RESULT_SHOWUSAGE;
00282
00283 if (AST_LIST_LOCK(&channels)) {
00284 ast_log(LOG_WARNING, "Unable to lock channel list\n");
00285 return RESULT_FAILURE;
00286 }
00287
00288 AST_LIST_TRAVERSE(&backends, cl, list) {
00289 if (!strncasecmp(cl->tech->type, argv[3], strlen(cl->tech->type))) {
00290 break;
00291 }
00292 }
00293
00294
00295 if (!cl) {
00296 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[3]);
00297 AST_LIST_UNLOCK(&channels);
00298 return RESULT_FAILURE;
00299 }
00300
00301 ast_cli(fd,
00302 "-- Info about channel driver: %s --\n"
00303 " Device State: %s\n"
00304 " Indication: %s\n"
00305 " Transfer : %s\n"
00306 " Capabilities: %d\n"
00307 " Digit Begin: %s\n"
00308 " Digit End: %s\n"
00309 " Send HTML : %s\n"
00310 " Image Support: %s\n"
00311 " Text Support: %s\n",
00312 cl->tech->type,
00313 (cl->tech->devicestate) ? "yes" : "no",
00314 (cl->tech->indicate) ? "yes" : "no",
00315 (cl->tech->transfer) ? "yes" : "no",
00316 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
00317 (cl->tech->send_digit_begin) ? "yes" : "no",
00318 (cl->tech->send_digit_end) ? "yes" : "no",
00319 (cl->tech->send_html) ? "yes" : "no",
00320 (cl->tech->send_image) ? "yes" : "no",
00321 (cl->tech->send_text) ? "yes" : "no"
00322
00323 );
00324
00325 AST_LIST_UNLOCK(&channels);
00326 return RESULT_SUCCESS;
00327 }
00328
00329 static char *complete_channeltypes_deprecated(const char *line, const char *word, int pos, int state)
00330 {
00331 struct chanlist *cl;
00332 int which = 0;
00333 int wordlen;
00334 char *ret = NULL;
00335
00336 if (pos != 2)
00337 return NULL;
00338
00339 wordlen = strlen(word);
00340
00341 AST_LIST_TRAVERSE(&backends, cl, list) {
00342 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
00343 ret = strdup(cl->tech->type);
00344 break;
00345 }
00346 }
00347
00348 return ret;
00349 }
00350
00351 static char *complete_channeltypes(const char *line, const char *word, int pos, int state)
00352 {
00353 struct chanlist *cl;
00354 int which = 0;
00355 int wordlen;
00356 char *ret = NULL;
00357
00358 if (pos != 3)
00359 return NULL;
00360
00361 wordlen = strlen(word);
00362
00363 AST_LIST_TRAVERSE(&backends, cl, list) {
00364 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
00365 ret = strdup(cl->tech->type);
00366 break;
00367 }
00368 }
00369
00370 return ret;
00371 }
00372
00373 static char show_channeltypes_usage[] =
00374 "Usage: core show channeltypes\n"
00375 " Lists available channel types registered in your Asterisk server.\n";
00376
00377 static char show_channeltype_usage[] =
00378 "Usage: core show channeltype <name>\n"
00379 " Show details about the specified channel type, <name>.\n";
00380
00381 static struct ast_cli_entry cli_show_channeltypes_deprecated = {
00382 { "show", "channeltypes", NULL },
00383 show_channeltypes, NULL,
00384 NULL };
00385
00386 static struct ast_cli_entry cli_show_channeltype_deprecated = {
00387 { "show", "channeltype", NULL },
00388 show_channeltype_deprecated, NULL,
00389 NULL, complete_channeltypes_deprecated };
00390
00391 static struct ast_cli_entry cli_channel[] = {
00392 { { "core", "show", "channeltypes", NULL },
00393 show_channeltypes, "List available channel types",
00394 show_channeltypes_usage, NULL, &cli_show_channeltypes_deprecated },
00395
00396 { { "core", "show", "channeltype", NULL },
00397 show_channeltype, "Give more details on that channel type",
00398 show_channeltype_usage, complete_channeltypes, &cli_show_channeltype_deprecated },
00399 };
00400
00401
00402 int ast_check_hangup(struct ast_channel *chan)
00403 {
00404 if (chan->_softhangup)
00405 return 1;
00406 if (!chan->tech_pvt)
00407 return 1;
00408 if (!chan->whentohangup)
00409 return 0;
00410 if (chan->whentohangup > time(NULL))
00411 return 0;
00412 chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
00413 return 1;
00414 }
00415
00416 static int ast_check_hangup_locked(struct ast_channel *chan)
00417 {
00418 int res;
00419 ast_channel_lock(chan);
00420 res = ast_check_hangup(chan);
00421 ast_channel_unlock(chan);
00422 return res;
00423 }
00424
00425
00426 char *ast_safe_string_alloc(const char *fmt, ...)
00427 {
00428 char *b2, buf[1];
00429 int len;
00430 va_list args;
00431
00432 va_start(args, fmt);
00433 len = vsnprintf(buf, 1, fmt, args);
00434 va_end(args);
00435
00436 if (!(b2 = ast_malloc(len + 1)))
00437 return NULL;
00438
00439 va_start(args, fmt);
00440 vsnprintf(b2, len + 1, fmt, args);
00441 va_end(args);
00442
00443 return b2;
00444 }
00445
00446
00447 void ast_begin_shutdown(int hangup)
00448 {
00449 struct ast_channel *c;
00450 shutting_down = 1;
00451 if (hangup) {
00452 AST_LIST_LOCK(&channels);
00453 AST_LIST_TRAVERSE(&channels, c, chan_list)
00454 ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
00455 AST_LIST_UNLOCK(&channels);
00456 }
00457 }
00458
00459
00460 int ast_active_channels(void)
00461 {
00462 struct ast_channel *c;
00463 int cnt = 0;
00464 AST_LIST_LOCK(&channels);
00465 AST_LIST_TRAVERSE(&channels, c, chan_list)
00466 cnt++;
00467 AST_LIST_UNLOCK(&channels);
00468 return cnt;
00469 }
00470
00471
00472 void ast_cancel_shutdown(void)
00473 {
00474 shutting_down = 0;
00475 }
00476
00477
00478 int ast_shutting_down(void)
00479 {
00480 return shutting_down;
00481 }
00482
00483
00484 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
00485 {
00486 chan->whentohangup = offset ? time(NULL) + offset : 0;
00487 ast_queue_frame(chan, &ast_null_frame);
00488 return;
00489 }
00490
00491
00492 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
00493 {
00494 time_t whentohangup;
00495
00496 if (chan->whentohangup == 0) {
00497 return (offset == 0) ? 0 : -1;
00498 } else {
00499 if (offset == 0)
00500 return (1);
00501 else {
00502 whentohangup = offset + time (NULL);
00503 if (chan->whentohangup < whentohangup)
00504 return (1);
00505 else if (chan->whentohangup == whentohangup)
00506 return (0);
00507 else
00508 return (-1);
00509 }
00510 }
00511 }
00512
00513
00514 int ast_channel_register(const struct ast_channel_tech *tech)
00515 {
00516 struct chanlist *chan;
00517
00518 AST_LIST_LOCK(&channels);
00519
00520 AST_LIST_TRAVERSE(&backends, chan, list) {
00521 if (!strcasecmp(tech->type, chan->tech->type)) {
00522 ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
00523 AST_LIST_UNLOCK(&channels);
00524 return -1;
00525 }
00526 }
00527
00528 if (!(chan = ast_calloc(1, sizeof(*chan)))) {
00529 AST_LIST_UNLOCK(&channels);
00530 return -1;
00531 }
00532 chan->tech = tech;
00533 AST_LIST_INSERT_HEAD(&backends, chan, list);
00534
00535 if (option_debug)
00536 ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
00537
00538 if (option_verbose > 1)
00539 ast_verbose(VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->tech->type,
00540 chan->tech->description);
00541
00542 AST_LIST_UNLOCK(&channels);
00543 return 0;
00544 }
00545
00546 void ast_channel_unregister(const struct ast_channel_tech *tech)
00547 {
00548 struct chanlist *chan;
00549
00550 if (option_debug)
00551 ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", tech->type);
00552
00553 AST_LIST_LOCK(&channels);
00554
00555 AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
00556 if (chan->tech == tech) {
00557 AST_LIST_REMOVE_CURRENT(&backends, list);
00558 free(chan);
00559 if (option_verbose > 1)
00560 ast_verbose(VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", tech->type);
00561 break;
00562 }
00563 }
00564 AST_LIST_TRAVERSE_SAFE_END
00565
00566 AST_LIST_UNLOCK(&channels);
00567 }
00568
00569 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
00570 {
00571 struct chanlist *chanls;
00572 const struct ast_channel_tech *ret = NULL;
00573
00574 if (AST_LIST_LOCK(&channels)) {
00575 ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
00576 return NULL;
00577 }
00578
00579 AST_LIST_TRAVERSE(&backends, chanls, list) {
00580 if (!strcasecmp(name, chanls->tech->type)) {
00581 ret = chanls->tech;
00582 break;
00583 }
00584 }
00585
00586 AST_LIST_UNLOCK(&channels);
00587
00588 return ret;
00589 }
00590
00591
00592 const char *ast_cause2str(int cause)
00593 {
00594 int x;
00595
00596 for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) {
00597 if (causes[x].cause == cause)
00598 return causes[x].desc;
00599 }
00600
00601 return "Unknown";
00602 }
00603
00604
00605 int ast_str2cause(const char *name)
00606 {
00607 int x;
00608
00609 for (x = 0; x < sizeof(causes) / sizeof(causes[0]); x++)
00610 if (strncasecmp(causes[x].name, name, strlen(causes[x].name)) == 0)
00611 return causes[x].cause;
00612
00613 return -1;
00614 }
00615
00616
00617 char *ast_state2str(enum ast_channel_state state)
00618 {
00619 char *buf;
00620
00621 switch(state) {
00622 case AST_STATE_DOWN:
00623 return "Down";
00624 case AST_STATE_RESERVED:
00625 return "Rsrvd";
00626 case AST_STATE_OFFHOOK:
00627 return "OffHook";
00628 case AST_STATE_DIALING:
00629 return "Dialing";
00630 case AST_STATE_RING:
00631 return "Ring";
00632 case AST_STATE_RINGING:
00633 return "Ringing";
00634 case AST_STATE_UP:
00635 return "Up";
00636 case AST_STATE_BUSY:
00637 return "Busy";
00638 case AST_STATE_DIALING_OFFHOOK:
00639 return "Dialing Offhook";
00640 case AST_STATE_PRERING:
00641 return "Pre-ring";
00642 default:
00643 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
00644 return "Unknown";
00645 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
00646 return buf;
00647 }
00648 }
00649
00650
00651 char *ast_transfercapability2str(int transfercapability)
00652 {
00653 switch(transfercapability) {
00654 case AST_TRANS_CAP_SPEECH:
00655 return "SPEECH";
00656 case AST_TRANS_CAP_DIGITAL:
00657 return "DIGITAL";
00658 case AST_TRANS_CAP_RESTRICTED_DIGITAL:
00659 return "RESTRICTED_DIGITAL";
00660 case AST_TRANS_CAP_3_1K_AUDIO:
00661 return "3K1AUDIO";
00662 case AST_TRANS_CAP_DIGITAL_W_TONES:
00663 return "DIGITAL_W_TONES";
00664 case AST_TRANS_CAP_VIDEO:
00665 return "VIDEO";
00666 default:
00667 return "UNKNOWN";
00668 }
00669 }
00670
00671
00672 int ast_best_codec(int fmts)
00673 {
00674
00675
00676 int x;
00677 static int prefs[] =
00678 {
00679
00680 AST_FORMAT_G722,
00681
00682 AST_FORMAT_ALAW,
00683
00684 AST_FORMAT_SLINEAR,
00685
00686 AST_FORMAT_ULAW,
00687
00688 AST_FORMAT_SPEEX,
00689
00690 AST_FORMAT_G726,
00691
00692 AST_FORMAT_G726_AAL2,
00693
00694 AST_FORMAT_ADPCM,
00695
00696
00697 AST_FORMAT_GSM,
00698
00699 AST_FORMAT_ILBC,
00700
00701 AST_FORMAT_G729A,
00702
00703 AST_FORMAT_G723_1,
00704
00705
00706 AST_FORMAT_LPC10,
00707 };
00708
00709
00710 fmts &= AST_FORMAT_AUDIO_MASK;
00711
00712
00713 for (x=0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++)
00714 if (fmts & prefs[x])
00715 return prefs[x];
00716 ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
00717 return 0;
00718 }
00719
00720 static const struct ast_channel_tech null_tech = {
00721 .type = "NULL",
00722 .description = "Null channel (should not see this)",
00723 };
00724
00725
00726 struct ast_channel *ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const int amaflag, const char *name_fmt, ...)
00727 {
00728 struct ast_channel *tmp;
00729 int x;
00730 int flags;
00731 struct varshead *headp;
00732 va_list ap1, ap2;
00733
00734
00735 if (shutting_down) {
00736 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
00737 return NULL;
00738 }
00739
00740 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
00741 return NULL;
00742
00743 if (!(tmp->sched = sched_context_create())) {
00744 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
00745 free(tmp);
00746 return NULL;
00747 }
00748
00749 if ((ast_string_field_init(tmp, 128))) {
00750 sched_context_destroy(tmp->sched);
00751 free(tmp);
00752 return NULL;
00753 }
00754
00755
00756
00757
00758 for (x = 0; x < AST_MAX_FDS - 2; x++)
00759 tmp->fds[x] = -1;
00760
00761 #ifdef HAVE_ZAPTEL
00762 tmp->timingfd = open("/dev/zap/timer", O_RDWR);
00763 if (tmp->timingfd > -1) {
00764
00765
00766 flags = 1;
00767 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
00768 needqueue = 0;
00769 }
00770 #else
00771 tmp->timingfd = -1;
00772 #endif
00773
00774 if (needqueue) {
00775 if (pipe(tmp->alertpipe)) {
00776 ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
00777 ast_string_field_free_pools(tmp);
00778 free(tmp);
00779 return NULL;
00780 } else {
00781 flags = fcntl(tmp->alertpipe[0], F_GETFL);
00782 fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
00783 flags = fcntl(tmp->alertpipe[1], F_GETFL);
00784 fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
00785 }
00786 } else
00787 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
00788
00789
00790 tmp->fds[AST_ALERT_FD] = tmp->alertpipe[0];
00791
00792 tmp->fds[AST_TIMING_FD] = tmp->timingfd;
00793 ast_string_field_set(tmp, name, "**Unknown**");
00794
00795
00796 tmp->_state = state;
00797
00798 tmp->streamid = -1;
00799
00800 tmp->fin = global_fin;
00801 tmp->fout = global_fout;
00802
00803 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
00804 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL),
00805 ast_atomic_fetchadd_int(&uniqueint, 1));
00806 } else {
00807 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME,
00808 (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
00809 }
00810
00811 tmp->cid.cid_name = ast_strdup(cid_name);
00812 tmp->cid.cid_num = ast_strdup(cid_num);
00813
00814 if (!ast_strlen_zero(name_fmt)) {
00815
00816
00817
00818
00819
00820
00821
00822 va_start(ap1, name_fmt);
00823 va_start(ap2, name_fmt);
00824 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
00825 va_end(ap1);
00826 va_end(ap2);
00827
00828
00829
00830
00831
00832
00833 manager_event(EVENT_FLAG_CALL, "Newchannel",
00834 "Channel: %s\r\n"
00835 "State: %s\r\n"
00836 "CallerIDNum: %s\r\n"
00837 "CallerIDName: %s\r\n"
00838 "Uniqueid: %s\r\n",
00839 tmp->name, ast_state2str(state),
00840 S_OR(cid_num, "<unknown>"),
00841 S_OR(cid_name, "<unknown>"),
00842 tmp->uniqueid);
00843 }
00844
00845
00846
00847
00848 if (amaflag)
00849 tmp->amaflags = amaflag;
00850 else
00851 tmp->amaflags = ast_default_amaflags;
00852
00853 if (!ast_strlen_zero(acctcode))
00854 ast_string_field_set(tmp, accountcode, acctcode);
00855 else
00856 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
00857
00858 if (!ast_strlen_zero(context))
00859 ast_copy_string(tmp->context, context, sizeof(tmp->context));
00860 else
00861 strcpy(tmp->context, "default");
00862
00863 if (!ast_strlen_zero(exten))
00864 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
00865 else
00866 strcpy(tmp->exten, "s");
00867
00868 tmp->priority = 1;
00869
00870 tmp->cdr = ast_cdr_alloc();
00871 ast_cdr_init(tmp->cdr, tmp);
00872 ast_cdr_start(tmp->cdr);
00873
00874 headp = &tmp->varshead;
00875 AST_LIST_HEAD_INIT_NOLOCK(headp);
00876
00877 ast_mutex_init(&tmp->lock);
00878
00879 AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
00880
00881 ast_string_field_set(tmp, language, defaultlanguage);
00882
00883 tmp->tech = &null_tech;
00884
00885 AST_LIST_LOCK(&channels);
00886 AST_LIST_INSERT_HEAD(&channels, tmp, chan_list);
00887 AST_LIST_UNLOCK(&channels);
00888
00889 return tmp;
00890 }
00891
00892
00893 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
00894 {
00895 struct ast_frame *f;
00896 struct ast_frame *cur;
00897 int blah = 1;
00898 int qlen = 0;
00899
00900
00901 if (!(f = ast_frdup(fin))) {
00902 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
00903 return -1;
00904 }
00905 ast_channel_lock(chan);
00906
00907
00908 if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
00909 ast_frfree(f);
00910 ast_channel_unlock(chan);
00911 return 0;
00912 }
00913
00914
00915 AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
00916 qlen++;
00917 }
00918
00919
00920 if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen > 128)) {
00921 if (fin->frametype != AST_FRAME_VOICE) {
00922 ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
00923 CRASH;
00924 } else {
00925 if (option_debug)
00926 ast_log(LOG_DEBUG, "Dropping voice to exceptionally long queue on %s\n", chan->name);
00927 ast_frfree(f);
00928 ast_channel_unlock(chan);
00929 return 0;
00930 }
00931 }
00932 AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
00933 if (chan->alertpipe[1] > -1) {
00934 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
00935 ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
00936 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
00937 #ifdef HAVE_ZAPTEL
00938 } else if (chan->timingfd > -1) {
00939 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
00940 #endif
00941 } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
00942 pthread_kill(chan->blocker, SIGURG);
00943 }
00944 ast_channel_unlock(chan);
00945 return 0;
00946 }
00947
00948
00949 int ast_queue_hangup(struct ast_channel *chan)
00950 {
00951 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
00952
00953 if (!ast_channel_trylock(chan)) {
00954 chan->_softhangup |= AST_SOFTHANGUP_DEV;
00955 ast_channel_unlock(chan);
00956 }
00957 return ast_queue_frame(chan, &f);
00958 }
00959
00960
00961 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
00962 {
00963 struct ast_frame f = { AST_FRAME_CONTROL, };
00964
00965 f.subclass = control;
00966
00967 return ast_queue_frame(chan, &f);
00968 }
00969
00970
00971 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
00972 const void *data, size_t datalen)
00973 {
00974 struct ast_frame f = { AST_FRAME_CONTROL, };
00975
00976 f.subclass = control;
00977 f.data = (void *) data;
00978 f.datalen = datalen;
00979
00980 return ast_queue_frame(chan, &f);
00981 }
00982
00983
00984 int ast_channel_defer_dtmf(struct ast_channel *chan)
00985 {
00986 int pre = 0;
00987
00988 if (chan) {
00989 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
00990 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
00991 }
00992 return pre;
00993 }
00994
00995
00996 void ast_channel_undefer_dtmf(struct ast_channel *chan)
00997 {
00998 if (chan)
00999 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
01000 }
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
01027 const char *name, const int namelen,
01028 const char *context, const char *exten)
01029 {
01030 const char *msg = prev ? "deadlock" : "initial deadlock";
01031 int retries;
01032 struct ast_channel *c;
01033 const struct ast_channel *_prev = prev;
01034
01035 for (retries = 0; retries < 10; retries++) {
01036 int done;
01037 AST_LIST_LOCK(&channels);
01038 AST_LIST_TRAVERSE(&channels, c, chan_list) {
01039 prev = _prev;
01040 if (prev) {
01041 if (c != prev)
01042 continue;
01043
01044 if ((c = AST_LIST_NEXT(c, chan_list)) == NULL) break;
01045
01046
01047
01048
01049 prev = NULL;
01050
01051
01052
01053
01054
01055 }
01056 if (name) {
01057 if ((!namelen && strcasecmp(c->name, name)) ||
01058 (namelen && strncasecmp(c->name, name, namelen)))
01059 continue;
01060 } else if (exten) {
01061 if (context && strcasecmp(c->context, context) &&
01062 strcasecmp(c->macrocontext, context))
01063 continue;
01064 if (strcasecmp(c->exten, exten) &&
01065 strcasecmp(c->macroexten, exten))
01066 continue;
01067 }
01068
01069 break;
01070 }
01071
01072
01073 done = c == NULL || ast_channel_trylock(c) == 0;
01074 if (!done) {
01075 if (option_debug)
01076 ast_log(LOG_DEBUG, "Avoiding %s for channel '%p'\n", msg, c);
01077 if (retries == 9) {
01078
01079
01080
01081 if (option_debug)
01082 ast_log(LOG_DEBUG, "Failure, could not lock '%p' after %d retries!\n", c, retries);
01083
01084
01085
01086
01087
01088 if (!(name && !namelen)) {
01089 prev = c;
01090 retries = -1;
01091 }
01092 }
01093 }
01094 AST_LIST_UNLOCK(&channels);
01095 if (done)
01096 return c;
01097
01098
01099
01100
01101 prev = _prev;
01102 usleep(1);
01103 }
01104
01105 return NULL;
01106 }
01107
01108
01109 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
01110 {
01111 return channel_find_locked(prev, NULL, 0, NULL, NULL);
01112 }
01113
01114
01115 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
01116 {
01117 return channel_find_locked(NULL, name, 0, NULL, NULL);
01118 }
01119
01120
01121 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
01122 {
01123 return channel_find_locked(NULL, name, namelen, NULL, NULL);
01124 }
01125
01126
01127 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
01128 const int namelen)
01129 {
01130 return channel_find_locked(chan, name, namelen, NULL, NULL);
01131 }
01132
01133
01134 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
01135 {
01136 return channel_find_locked(NULL, NULL, 0, context, exten);
01137 }
01138
01139
01140 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
01141 const char *context)
01142 {
01143 return channel_find_locked(chan, NULL, 0, context, exten);
01144 }
01145
01146
01147 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
01148 {
01149 struct ast_frame *f;
01150
01151 while (ms > 0) {
01152 if (cond && ((*cond)(data) == 0))
01153 return 0;
01154 ms = ast_waitfor(chan, ms);
01155 if (ms < 0)
01156 return -1;
01157 if (ms > 0) {
01158 f = ast_read(chan);
01159 if (!f)
01160 return -1;
01161 ast_frfree(f);
01162 }
01163 }
01164 return 0;
01165 }
01166
01167
01168 int ast_safe_sleep(struct ast_channel *chan, int ms)
01169 {
01170 return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
01171 }
01172
01173 static void free_cid(struct ast_callerid *cid)
01174 {
01175 if (cid->cid_dnid)
01176 free(cid->cid_dnid);
01177 if (cid->cid_num)
01178 free(cid->cid_num);
01179 if (cid->cid_name)
01180 free(cid->cid_name);
01181 if (cid->cid_ani)
01182 free(cid->cid_ani);
01183 if (cid->cid_rdnis)
01184 free(cid->cid_rdnis);
01185 }
01186
01187
01188 void ast_channel_free(struct ast_channel *chan)
01189 {
01190 int fd;
01191 struct ast_var_t *vardata;
01192 struct ast_frame *f;
01193 struct varshead *headp;
01194 struct ast_datastore *datastore = NULL;
01195 char name[AST_CHANNEL_NAME];
01196
01197 headp=&chan->varshead;
01198
01199 AST_LIST_LOCK(&channels);
01200 if (!AST_LIST_REMOVE(&channels, chan, chan_list)) {
01201 AST_LIST_UNLOCK(&channels);
01202 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
01203 }
01204
01205
01206 ast_channel_lock(chan);
01207 ast_channel_unlock(chan);
01208 if (chan->tech_pvt) {
01209 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
01210 free(chan->tech_pvt);
01211 }
01212
01213 if (chan->sched)
01214 sched_context_destroy(chan->sched);
01215
01216 ast_copy_string(name, chan->name, sizeof(name));
01217
01218
01219 if (chan->monitor)
01220 chan->monitor->stop( chan, 0 );
01221
01222
01223 if (chan->music_state)
01224 ast_moh_cleanup(chan);
01225
01226
01227 if (chan->whisper)
01228 ast_channel_whisper_stop(chan);
01229
01230
01231 if (chan->readtrans)
01232 ast_translator_free_path(chan->readtrans);
01233 if (chan->writetrans)
01234 ast_translator_free_path(chan->writetrans);
01235 if (chan->pbx)
01236 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
01237 free_cid(&chan->cid);
01238 ast_mutex_destroy(&chan->lock);
01239
01240 if ((fd = chan->alertpipe[0]) > -1)
01241 close(fd);
01242 if ((fd = chan->alertpipe[1]) > -1)
01243 close(fd);
01244 if ((fd = chan->timingfd) > -1)
01245 close(fd);
01246 while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
01247 ast_frfree(f);
01248
01249
01250 while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
01251
01252 ast_channel_datastore_free(datastore);
01253 AST_LIST_HEAD_INIT_NOLOCK(&chan->datastores);
01254
01255
01256
01257
01258 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
01259 ast_var_delete(vardata);
01260
01261 ast_app_group_discard(chan);
01262
01263
01264 ast_jb_destroy(chan);
01265
01266 ast_string_field_free_pools(chan);
01267 free(chan);
01268 AST_LIST_UNLOCK(&channels);
01269
01270 ast_device_state_changed_literal(name);
01271 }
01272
01273 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, char *uid)
01274 {
01275 struct ast_datastore *datastore = NULL;
01276
01277
01278 if (info == NULL) {
01279 return NULL;
01280 }
01281
01282
01283 datastore = ast_calloc(1, sizeof(*datastore));
01284 if (datastore == NULL) {
01285 return NULL;
01286 }
01287
01288 datastore->info = info;
01289
01290 datastore->uid = ast_strdup(uid);
01291
01292 return datastore;
01293 }
01294
01295 int ast_channel_datastore_free(struct ast_datastore *datastore)
01296 {
01297 int res = 0;
01298
01299
01300 if (datastore->info->destroy != NULL && datastore->data != NULL) {
01301 datastore->info->destroy(datastore->data);
01302 datastore->data = NULL;
01303 }
01304
01305
01306 if (datastore->uid != NULL) {
01307 free(datastore->uid);
01308 datastore->uid = NULL;
01309 }
01310
01311
01312 free(datastore);
01313
01314 return res;
01315 }
01316
01317 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
01318 {
01319 int res = 0;
01320
01321 AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
01322
01323 return res;
01324 }
01325
01326 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
01327 {
01328 struct ast_datastore *datastore2 = NULL;
01329 int res = -1;
01330
01331
01332 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore2, entry) {
01333 if (datastore2 == datastore) {
01334 AST_LIST_REMOVE_CURRENT(&chan->datastores, entry);
01335 res = 0;
01336 break;
01337 }
01338 }
01339 AST_LIST_TRAVERSE_SAFE_END
01340
01341 return res;
01342 }
01343
01344 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, char *uid)
01345 {
01346 struct ast_datastore *datastore = NULL;
01347
01348 if (info == NULL)
01349 return NULL;
01350
01351 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
01352 if (datastore->info == info) {
01353 if (uid != NULL && datastore->uid != NULL) {
01354 if (!strcasecmp(uid, datastore->uid)) {
01355
01356 break;
01357 }
01358 } else {
01359
01360 break;
01361 }
01362 }
01363 }
01364 AST_LIST_TRAVERSE_SAFE_END
01365
01366 return datastore;
01367 }
01368
01369 int ast_channel_spy_add(struct ast_channel *chan, struct ast_channel_spy *spy)
01370 {
01371
01372 spy->chan = chan;
01373
01374 if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) {
01375 ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n",
01376 spy->type, chan->name);
01377 return -1;
01378 }
01379
01380 if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST) && (spy->read_queue.format != AST_FORMAT_SLINEAR)) {
01381 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
01382 ast_getformatname(spy->read_queue.format));
01383 return -1;
01384 }
01385
01386 if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST) && (spy->write_queue.format != AST_FORMAT_SLINEAR)) {
01387 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
01388 ast_getformatname(spy->write_queue.format));
01389 return -1;
01390 }
01391
01392 if (ast_test_flag(spy, CHANSPY_MIXAUDIO) &&
01393 ((spy->read_queue.format != AST_FORMAT_SLINEAR) ||
01394 (spy->write_queue.format != AST_FORMAT_SLINEAR))) {
01395 ast_log(LOG_WARNING, "Cannot provide audio mixing on '%s'-'%s' format spies\n",
01396 ast_getformatname(spy->read_queue.format), ast_getformatname(spy->write_queue.format));
01397 return -1;
01398 }
01399
01400 if (!chan->spies) {
01401 if (!(chan->spies = ast_calloc(1, sizeof(*chan->spies)))) {
01402 return -1;
01403 }
01404
01405 AST_LIST_HEAD_INIT_NOLOCK(&chan->spies->list);
01406 AST_LIST_INSERT_HEAD(&chan->spies->list, spy, list);
01407 } else {
01408 AST_LIST_INSERT_TAIL(&chan->spies->list, spy, list);
01409 }
01410
01411 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
01412 ast_cond_init(&spy->trigger, NULL);
01413 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
01414 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
01415 }
01416
01417 if (option_debug)
01418 ast_log(LOG_DEBUG, "Spy %s added to channel %s\n",
01419 spy->type, chan->name);
01420
01421 return 0;
01422 }
01423
01424
01425 static void spy_cleanup(struct ast_channel *chan)
01426 {
01427 if (!AST_LIST_EMPTY(&chan->spies->list))
01428 return;
01429 if (chan->spies->read_translator.path)
01430 ast_translator_free_path(chan->spies->read_translator.path);
01431 if (chan->spies->write_translator.path)
01432 ast_translator_free_path(chan->spies->write_translator.path);
01433 free(chan->spies);
01434 chan->spies = NULL;
01435 return;
01436 }
01437
01438
01439 static void spy_detach(struct ast_channel_spy *spy, struct ast_channel *chan)
01440 {
01441
01442 if (spy->status != CHANSPY_DONE) {
01443 ast_mutex_lock(&spy->lock);
01444
01445 spy->status = CHANSPY_STOP;
01446 spy->chan = NULL;
01447
01448 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
01449 ast_cond_signal(&spy->trigger);
01450 ast_mutex_unlock(&spy->lock);
01451 }
01452
01453
01454 if (option_debug)
01455 ast_log(LOG_DEBUG, "Spy %s removed from channel %s\n", spy->type, chan->name);
01456
01457 return;
01458 }
01459
01460 void ast_channel_spy_stop_by_type(struct ast_channel *chan, const char *type)
01461 {
01462 struct ast_channel_spy *spy = NULL;
01463
01464 if (!chan->spies)
01465 return;
01466
01467 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
01468 if ((spy->type == type) && (spy->status == CHANSPY_RUNNING)) {
01469 AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
01470 spy_detach(spy, chan);
01471 }
01472 }
01473 AST_LIST_TRAVERSE_SAFE_END
01474 spy_cleanup(chan);
01475 }
01476
01477 void ast_channel_spy_trigger_wait(struct ast_channel_spy *spy)
01478 {
01479 struct timeval tv;
01480 struct timespec ts;
01481
01482 tv = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
01483 ts.tv_sec = tv.tv_sec;
01484 ts.tv_nsec = tv.tv_usec * 1000;
01485
01486 ast_cond_timedwait(&spy->trigger, &spy->lock, &ts);
01487 }
01488
01489 void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *spy)
01490 {
01491 if (!chan->spies)
01492 return;
01493
01494 AST_LIST_REMOVE(&chan->spies->list, spy, list);
01495 spy_detach(spy, chan);
01496 spy_cleanup(chan);
01497 }
01498
01499 void ast_channel_spy_free(struct ast_channel_spy *spy)
01500 {
01501 struct ast_frame *f = NULL;
01502
01503 if (spy->status == CHANSPY_DONE)
01504 return;
01505
01506
01507 spy->status = CHANSPY_DONE;
01508
01509
01510 while ((f = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list)))
01511 ast_frfree(f);
01512 while ((f = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list)))
01513 ast_frfree(f);
01514
01515
01516 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
01517 ast_cond_destroy(&spy->trigger);
01518
01519
01520 ast_mutex_destroy(&spy->lock);
01521
01522 return;
01523 }
01524
01525 static void detach_spies(struct ast_channel *chan)
01526 {
01527 struct ast_channel_spy *spy = NULL;
01528
01529 if (!chan->spies)
01530 return;
01531
01532 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
01533 AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
01534 spy_detach(spy, chan);
01535 }
01536 AST_LIST_TRAVERSE_SAFE_END
01537
01538 spy_cleanup(chan);
01539 }
01540
01541
01542 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
01543 {
01544 if (option_debug)
01545 ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name);
01546
01547 chan->_softhangup |= cause;
01548 ast_queue_frame(chan, &ast_null_frame);
01549
01550 if (ast_test_flag(chan, AST_FLAG_BLOCKING))
01551 pthread_kill(chan->blocker, SIGURG);
01552 return 0;
01553 }
01554
01555
01556 int ast_softhangup(struct ast_channel *chan, int cause)
01557 {
01558 int res;
01559 ast_channel_lock(chan);
01560 res = ast_softhangup_nolock(chan, cause);
01561 ast_channel_unlock(chan);
01562 return res;
01563 }
01564
01565 enum spy_direction {
01566 SPY_READ,
01567 SPY_WRITE,
01568 };
01569
01570 #define SPY_QUEUE_SAMPLE_LIMIT 4000
01571
01572 static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f, enum spy_direction dir)
01573 {
01574 struct ast_frame *translated_frame = NULL;
01575 struct ast_channel_spy *spy;
01576 struct channel_spy_trans *trans;
01577
01578 trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;
01579
01580 AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
01581 struct ast_channel_spy_queue *queue;
01582 struct ast_frame *duped_fr;
01583
01584 if (spy->status != CHANSPY_RUNNING)
01585 continue;
01586
01587 ast_mutex_lock(&spy->lock);
01588
01589 queue = (dir == SPY_READ) ? &spy->read_queue : &spy->write_queue;
01590
01591 if ((queue->format == AST_FORMAT_SLINEAR) && (f->subclass != AST_FORMAT_SLINEAR)) {
01592 if (!translated_frame) {
01593 if (trans->path && (trans->last_format != f->subclass)) {
01594 ast_translator_free_path(trans->path);
01595 trans->path = NULL;
01596 }
01597 if (!trans->path) {
01598 if (option_debug)
01599 ast_log(LOG_DEBUG, "Building translator from %s to SLINEAR for spies on channel %s\n",
01600 ast_getformatname(f->subclass), chan->name);
01601 if ((trans->path = ast_translator_build_path(AST_FORMAT_SLINEAR, f->subclass)) == NULL) {
01602 ast_log(LOG_WARNING, "Cannot build a path from %s to %s\n",
01603 ast_getformatname(f->subclass), ast_getformatname(AST_FORMAT_SLINEAR));
01604 ast_mutex_unlock(&spy->lock);
01605 continue;
01606 } else {
01607 trans->last_format = f->subclass;
01608 }
01609 }
01610 if (!(translated_frame = ast_translate(trans->path, f, 0))) {
01611 ast_log(LOG_ERROR, "Translation to %s failed, dropping frame for spies\n",
01612 ast_getformatname(AST_FORMAT_SLINEAR));
01613 ast_mutex_unlock(&spy->lock);
01614 break;
01615 }
01616 }
01617 duped_fr = ast_frdup(translated_frame);
01618 } else if (f->subclass != queue->format) {
01619 ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
01620 spy->type, chan->name,
01621 ast_getformatname(queue->format), ast_getformatname(f->subclass));
01622 ast_mutex_unlock(&spy->lock);
01623 continue;
01624 } else
01625 duped_fr = ast_frdup(f);
01626
01627 AST_LIST_INSERT_TAIL(&queue->list, duped_fr, frame_list);
01628
01629 queue->samples += f->samples;
01630
01631 if (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
01632 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
01633 switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
01634 case CHANSPY_TRIGGER_READ:
01635 if (dir == SPY_WRITE) {
01636 ast_set_flag(spy, CHANSPY_TRIGGER_WRITE);
01637 ast_clear_flag(spy, CHANSPY_TRIGGER_READ);
01638 if (option_debug)
01639 ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to write-trigger mode\n",
01640 spy->type, chan->name);
01641 }
01642 break;
01643 case CHANSPY_TRIGGER_WRITE:
01644 if (dir == SPY_READ) {
01645 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
01646 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
01647 if (option_debug)
01648 ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to read-trigger mode\n",
01649 spy->type, chan->name);
01650 }
01651 break;
01652 }
01653 if (option_debug)
01654 ast_log(LOG_DEBUG, "Triggering queue flush for spy '%s' on '%s'\n",
01655 spy->type, chan->name);
01656 ast_set_flag(spy, CHANSPY_TRIGGER_FLUSH);
01657 ast_cond_signal(&spy->trigger);
01658 } else {
01659 if (option_debug)
01660 ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
01661 spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
01662 while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
01663 struct ast_frame *drop = AST_LIST_REMOVE_HEAD(&queue->list, frame_list);
01664 queue->samples -= drop->samples;
01665 ast_frfree(drop);
01666 }
01667 }
01668 } else {
01669 switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
01670 case CHANSPY_TRIGGER_READ:
01671 if (dir == SPY_READ)
01672 ast_cond_signal(&spy->trigger);
01673 break;
01674 case CHANSPY_TRIGGER_WRITE:
01675 if (dir == SPY_WRITE)
01676 ast_cond_signal(&spy->trigger);
01677 break;
01678 }
01679 }
01680
01681 ast_mutex_unlock(&spy->lock);
01682 }
01683
01684 if (translated_frame)
01685 ast_frfree(translated_frame);
01686 }
01687
01688 static void free_translation(struct ast_channel *clone)
01689 {
01690 if (clone->writetrans)
01691 ast_translator_free_path(clone->writetrans);
01692 if (clone->readtrans)
01693 ast_translator_free_path(clone->readtrans);
01694 clone->writetrans = NULL;
01695 clone->readtrans = NULL;
01696 clone->rawwriteformat = clone->nativeformats;
01697 clone->rawreadformat = clone->nativeformats;
01698 }
01699
01700
01701 int ast_hangup(struct ast_channel *chan)
01702 {
01703 int res = 0;
01704 struct ast_cdr *cdr = NULL;
01705
01706
01707
01708 ast_channel_lock(chan);
01709
01710 detach_spies(chan);
01711
01712 if (chan->masq) {
01713 if (ast_do_masquerade(chan))
01714 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
01715 }
01716
01717 if (chan->masq) {
01718 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
01719 ast_channel_unlock(chan);
01720 return 0;
01721 }
01722
01723
01724 if (chan->masqr) {
01725 ast_set_flag(chan, AST_FLAG_ZOMBIE);
01726 ast_channel_unlock(chan);
01727 return 0;
01728 }
01729 free_translation(chan);
01730
01731 if (chan->stream) {
01732 ast_closestream(chan->stream);
01733 chan->stream = NULL;
01734 }
01735
01736 if (chan->vstream) {
01737 ast_closestream(chan->vstream);
01738 chan->vstream = NULL;
01739 }
01740 if (chan->sched) {
01741 sched_context_destroy(chan->sched);
01742 chan->sched = NULL;
01743 }
01744
01745 if (chan->generatordata)
01746 chan->generator->release(chan, chan->generatordata);
01747 chan->generatordata = NULL;
01748 chan->generator = NULL;
01749 if (chan->cdr) {
01750 ast_cdr_end(chan->cdr);
01751 cdr = chan->cdr;
01752 chan->cdr = NULL;
01753 }
01754 if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
01755 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
01756 "is blocked by thread %ld in procedure %s! Expect a failure\n",
01757 (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
01758 CRASH;
01759 }
01760 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
01761 if (option_debug)
01762 ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
01763 if (chan->tech->hangup)
01764 res = chan->tech->hangup(chan);
01765 } else {
01766 if (option_debug)
01767 ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name);
01768 }
01769
01770 ast_channel_unlock(chan);
01771 manager_event(EVENT_FLAG_CALL, "Hangup",
01772 "Channel: %s\r\n"
01773 "Uniqueid: %s\r\n"
01774 "Cause: %d\r\n"
01775 "Cause-txt: %s\r\n",
01776 chan->name,
01777 chan->uniqueid,
01778 chan->hangupcause,
01779 ast_cause2str(chan->hangupcause)
01780 );
01781 ast_channel_free(chan);
01782
01783 if (cdr)
01784 ast_cdr_detach(cdr);
01785
01786 return res;
01787 }
01788
01789 int ast_answer(struct ast_channel *chan)
01790 {
01791 int res = 0;
01792 ast_channel_lock(chan);
01793
01794 if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
01795 ast_channel_unlock(chan);
01796 return 0;
01797 }
01798
01799 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
01800 ast_channel_unlock(chan);
01801 return -1;
01802 }
01803 switch(chan->_state) {
01804 case AST_STATE_RINGING:
01805 case AST_STATE_RING:
01806 if (chan->tech->answer)
01807 res = chan->tech->answer(chan);
01808 ast_setstate(chan, AST_STATE_UP);
01809 ast_cdr_answer(chan->cdr);
01810 break;
01811 case AST_STATE_UP:
01812 ast_cdr_answer(chan->cdr);
01813 break;
01814 default:
01815 break;
01816 }
01817 ast_channel_unlock(chan);
01818 return res;
01819 }
01820
01821 void ast_deactivate_generator(struct ast_channel *chan)
01822 {
01823 ast_channel_lock(chan);
01824 if (chan->generatordata) {
01825 if (chan->generator && chan->generator->release)
01826 chan->generator->release(chan, chan->generatordata);
01827 chan->generatordata = NULL;
01828 chan->generator = NULL;
01829 chan->fds[AST_GENERATOR_FD] = -1;
01830 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
01831 ast_settimeout(chan, 0, NULL, NULL);
01832 }
01833 ast_channel_unlock(chan);
01834 }
01835
01836 static int generator_force(void *data)
01837 {
01838
01839 void *tmp;
01840 int res;
01841 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
01842 struct ast_channel *chan = data;
01843 tmp = chan->generatordata;
01844 chan->generatordata = NULL;
01845 generate = chan->generator->generate;
01846 res = generate(chan, tmp, 0, 160);
01847 chan->generatordata = tmp;
01848 if (res) {
01849 if (option_debug)
01850 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
01851 ast_deactivate_generator(chan);
01852 }
01853 return 0;
01854 }
01855
01856 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
01857 {
01858 int res = 0;
01859
01860 ast_channel_lock(chan);
01861
01862 if (chan->generatordata) {
01863 if (chan->generator && chan->generator->release)
01864 chan->generator->release(chan, chan->generatordata);
01865 chan->generatordata = NULL;
01866 }
01867
01868 ast_prod(chan);
01869 if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
01870 res = -1;
01871 }
01872
01873 if (!res) {
01874 ast_settimeout(chan, 160, generator_force, chan);
01875 chan->generator = gen;
01876 }
01877
01878 ast_channel_unlock(chan);
01879
01880 return res;
01881 }
01882
01883
01884 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
01885 {
01886 int winner = -1;
01887 ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
01888 return winner;
01889 }
01890
01891
01892 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
01893 int *exception, int *outfd, int *ms)
01894 {
01895 struct timeval start = { 0 , 0 };
01896 struct pollfd *pfds;
01897 int res;
01898 long rms;
01899 int x, y, max;
01900 int sz;
01901 time_t now = 0;
01902 long whentohangup = 0, diff;
01903 struct ast_channel *winner = NULL;
01904 struct fdmap {
01905 int chan;
01906 int fdno;
01907 } *fdmap;
01908
01909 sz = n * AST_MAX_FDS + nfds;
01910 pfds = alloca(sizeof(*pfds) * sz);
01911 fdmap = alloca(sizeof(*fdmap) * sz);
01912
01913 if (outfd)
01914 *outfd = -99999;
01915 if (exception)
01916 *exception = 0;
01917
01918
01919 for (x=0; x < n; x++) {
01920 ast_channel_lock(c[x]);
01921 if (c[x]->masq) {
01922 if (ast_do_masquerade(c[x])) {
01923 ast_log(LOG_WARNING, "Masquerade failed\n");
01924 *ms = -1;
01925 ast_channel_unlock(c[x]);
01926 return NULL;
01927 }
01928 }
01929 if (c[x]->whentohangup) {
01930 if (!whentohangup)
01931 time(&now);
01932 diff = c[x]->whentohangup - now;
01933 if (diff < 1) {
01934
01935 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
01936 ast_channel_unlock(c[x]);
01937 return c[x];
01938 }
01939 if (!whentohangup || (diff < whentohangup))
01940 whentohangup = diff;
01941 }
01942 ast_channel_unlock(c[x]);
01943 }
01944
01945 rms = *ms;
01946 if (whentohangup) {
01947 rms = whentohangup * 1000;
01948 if (*ms >= 0 && *ms < rms)
01949 rms = *ms;
01950 }
01951
01952
01953
01954
01955
01956 max = 0;
01957 for (x=0; x<n; x++) {
01958 for (y=0; y<AST_MAX_FDS; y++) {
01959 fdmap[max].fdno = y;
01960 fdmap[max].chan = x;
01961 max += ast_add_fd(&pfds[max], c[x]->fds[y]);
01962 }
01963 CHECK_BLOCKING(c[x]);
01964 }
01965
01966 for (x=0; x<nfds; x++) {
01967 fdmap[max].chan = -1;
01968 max += ast_add_fd(&pfds[max], fds[x]);
01969 }
01970
01971 if (*ms > 0)
01972 start = ast_tvnow();
01973
01974 if (sizeof(int) == 4) {
01975 do {
01976 int kbrms = rms;
01977 if (kbrms > 600000)
01978 kbrms = 600000;
01979 res = poll(pfds, max, kbrms);
01980 if (!res)
01981 rms -= kbrms;
01982 } while (!res && (rms > 0));
01983 } else {
01984 res = poll(pfds, max, rms);
01985 }
01986 for (x=0; x<n; x++)
01987 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
01988 if (res < 0) {
01989 if (errno != EINTR)
01990 *ms = -1;
01991 return NULL;
01992 }
01993 if (whentohangup) {
01994 time(&now);
01995 for (x=0; x<n; x++) {
01996 if (c[x]->whentohangup && now >= c[x]->whentohangup) {
01997 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
01998 if (winner == NULL)
01999 winner = c[x];
02000 }
02001 }
02002 }
02003 if (res == 0) {
02004 *ms = 0;
02005 return winner;
02006 }
02007
02008
02009
02010
02011
02012 for (x = 0; x < max; x++) {
02013 res = pfds[x].revents;
02014 if (res == 0)
02015 continue;
02016 if (fdmap[x].chan >= 0) {
02017 winner = c[fdmap[x].chan];
02018 if (res & POLLPRI)
02019 ast_set_flag(winner, AST_FLAG_EXCEPTION);
02020 else
02021 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
02022 winner->fdno = fdmap[x].fdno;
02023 } else {
02024 if (outfd)
02025 *outfd = pfds[x].fd;
02026 if (exception)
02027 *exception = (res & POLLPRI) ? -1 : 0;
02028 winner = NULL;
02029 }
02030 }
02031 if (*ms > 0) {
02032 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
02033 if (*ms < 0)
02034 *ms = 0;
02035 }
02036 return winner;
02037 }
02038
02039 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
02040 {
02041 return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
02042 }
02043
02044 int ast_waitfor(struct ast_channel *c, int ms)
02045 {
02046 int oldms = ms;
02047
02048 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
02049 if ((ms < 0) && (oldms < 0))
02050 ms = 0;
02051 return ms;
02052 }
02053
02054
02055 int ast_waitfordigit(struct ast_channel *c, int ms)
02056 {
02057 return ast_waitfordigit_full(c, ms, -1, -1);
02058 }
02059
02060 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data)
02061 {
02062 int res = -1;
02063 #ifdef HAVE_ZAPTEL
02064 if (c->timingfd > -1) {
02065 if (!func) {
02066 samples = 0;
02067 data = 0;
02068 }
02069 if (option_debug)
02070 ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
02071 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
02072 c->timingfunc = func;
02073 c->timingdata = data;
02074 }
02075 #endif
02076 return res;
02077 }
02078
02079 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
02080 {
02081 int begin_digit = 0;
02082
02083
02084 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
02085 return -1;
02086
02087 while (ms) {
02088 struct ast_channel *rchan;
02089 int outfd;
02090
02091 errno = 0;
02092 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
02093 if (!rchan && outfd < 0 && ms) {
02094 if (errno == 0 || errno == EINTR)
02095 continue;
02096 ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
02097 return -1;
02098 } else if (outfd > -1) {
02099
02100 return 1;
02101 } else if (rchan) {
02102 int res;
02103 struct ast_frame *f = ast_read(c);
02104 if (!f)
02105 return -1;
02106
02107 switch(f->frametype) {
02108 case AST_FRAME_DTMF_BEGIN:
02109 begin_digit = f->subclass;
02110 break;
02111 case AST_FRAME_DTMF_END:
02112 if (begin_digit != f->subclass)
02113 break;
02114 res = f->subclass;
02115 ast_frfree(f);
02116 return res;
02117 case AST_FRAME_CONTROL:
02118 switch(f->subclass) {
02119 case AST_CONTROL_HANGUP:
02120 ast_frfree(f);
02121 return -1;
02122 case AST_CONTROL_RINGING:
02123 case AST_CONTROL_ANSWER:
02124
02125 break;
02126 default:
02127 ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
02128 break;
02129 }
02130 break;
02131 case AST_FRAME_VOICE:
02132
02133 if (audiofd > -1)
02134 write(audiofd, f->data, f->datalen);
02135 default:
02136
02137 break;
02138 }
02139 ast_frfree(f);
02140 }
02141 }
02142 return 0;
02143 }
02144
02145 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
02146 {
02147 if (chan->generatordata && !ast_internal_timing_enabled(chan)) {
02148 void *tmp = chan->generatordata;
02149 int res;
02150
02151 if (chan->timingfunc) {
02152 if (option_debug > 1)
02153 ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
02154 ast_settimeout(chan, 0, NULL, NULL);
02155 }
02156
02157 chan->generatordata = NULL;
02158 res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
02159 chan->generatordata = tmp;
02160 if (res) {
02161 if (option_debug > 1)
02162 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
02163 ast_deactivate_generator(chan);
02164 }
02165
02166 } else if (f->frametype == AST_FRAME_CNG) {
02167 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
02168 if (option_debug > 1)
02169 ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
02170 ast_settimeout(chan, 160, generator_force, chan);
02171 }
02172 }
02173 }
02174
02175 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
02176 {
02177 struct ast_frame *f = NULL;
02178 int blah;
02179 int prestate;
02180
02181
02182
02183
02184 ast_channel_lock(chan);
02185 if (chan->masq) {
02186 if (ast_do_masquerade(chan))
02187 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
02188 else
02189 f = &ast_null_frame;
02190 goto done;
02191 }
02192
02193
02194 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
02195 if (chan->generator)
02196 ast_deactivate_generator(chan);
02197 goto done;
02198 }
02199 prestate = chan->_state;
02200
02201 if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) &&
02202 !ast_strlen_zero(chan->dtmfq) &&
02203 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
02204
02205 chan->dtmff.subclass = chan->dtmfq[0];
02206
02207 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
02208 f = &chan->dtmff;
02209 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
02210 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
02211 chan->dtmff.frametype = AST_FRAME_DTMF_END;
02212 } else {
02213 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %d queued on %s\n", f->subclass, AST_DEFAULT_EMULATE_DTMF_DURATION, chan->name);
02214 chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
02215 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
02216 chan->emulate_dtmf_digit = f->subclass;
02217 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
02218 }
02219 chan->dtmf_tv = ast_tvnow();
02220 goto done;
02221 }
02222
02223
02224
02225 if (chan->alertpipe[0] > -1)
02226 read(chan->alertpipe[0], &blah, sizeof(blah));
02227
02228 #ifdef HAVE_ZAPTEL
02229 if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
02230 int res;
02231
02232 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
02233 blah = -1;
02234
02235 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
02236 if (res)
02237 blah = ZT_EVENT_TIMER_EXPIRED;
02238
02239 if (blah == ZT_EVENT_TIMER_PING) {
02240 if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
02241
02242 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
02243 ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
02244 }
02245 }
02246 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
02247 ioctl(chan->timingfd, ZT_TIMERACK, &blah);
02248 if (chan->timingfunc) {
02249
02250 int (*func)(void *) = chan->timingfunc;
02251 void *data = chan->timingdata;
02252 ast_channel_unlock(chan);
02253 func(data);
02254 } else {
02255 blah = 0;
02256 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
02257 chan->timingdata = NULL;
02258 ast_channel_unlock(chan);
02259 }
02260
02261 return &ast_null_frame;
02262 } else
02263 ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
02264 } else
02265 #endif
02266 if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
02267
02268
02269
02270 void *tmp = chan->generatordata;
02271 chan->generatordata = NULL;
02272 chan->generator->generate(chan, tmp, -1, -1);
02273 chan->generatordata = tmp;
02274 f = &ast_null_frame;
02275 goto done;
02276 }
02277
02278
02279 if (!AST_LIST_EMPTY(&chan->readq)) {
02280 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
02281
02282
02283 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
02284 ast_frfree(f);
02285 f = NULL;
02286 }
02287 } else {
02288 chan->blocker = pthread_self();
02289 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
02290 if (chan->tech->exception)
02291 f = chan->tech->exception(chan);
02292 else {
02293 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
02294 f = &ast_null_frame;
02295 }
02296
02297 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
02298 } else if (chan->tech->read)
02299 f = chan->tech->read(chan);
02300 else
02301 ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
02302 }
02303
02304 if (f) {
02305
02306
02307
02308
02309
02310 if (AST_LIST_NEXT(f, frame_list)) {
02311 AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
02312 AST_LIST_NEXT(f, frame_list) = NULL;
02313 }
02314
02315 switch (f->frametype) {
02316 case AST_FRAME_CONTROL:
02317 if (f->subclass == AST_CONTROL_ANSWER) {
02318 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
02319 if (option_debug)
02320 ast_log(LOG_DEBUG, "Ignoring answer on an inbound call!\n");
02321 ast_frfree(f);
02322 f = &ast_null_frame;
02323 } else if (prestate == AST_STATE_UP) {
02324 if (option_debug)
02325 ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
02326 ast_frfree(f);
02327 f = &ast_null_frame;
02328 } else {
02329
02330 ast_setstate(chan, AST_STATE_UP);
02331 if (!chan->cdr) {
02332
02333
02334 chan->cdr = ast_cdr_alloc();
02335 ast_cdr_init(chan->cdr, chan);
02336 ast_cdr_start(chan->cdr);
02337 }
02338
02339 ast_cdr_answer(chan->cdr);
02340 }
02341 }
02342 break;
02343 case AST_FRAME_DTMF_END:
02344 ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
02345
02346
02347 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
02348 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
02349 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
02350 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
02351 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
02352 } else
02353 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
02354 ast_frfree(f);
02355 f = &ast_null_frame;
02356 } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
02357 if (!ast_tvzero(chan->dtmf_tv) &&
02358 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
02359
02360 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
02361 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
02362 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
02363 } else
02364 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
02365 ast_frfree(f);
02366 f = &ast_null_frame;
02367 } else {
02368
02369 f->frametype = AST_FRAME_DTMF_BEGIN;
02370 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
02371 chan->emulate_dtmf_digit = f->subclass;
02372 chan->dtmf_tv = ast_tvnow();
02373 if (f->len) {
02374 if (f->len > AST_MIN_DTMF_DURATION)
02375 chan->emulate_dtmf_duration = f->len;
02376 else
02377 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
02378 } else
02379 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
02380 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
02381 }
02382 } else {
02383 struct timeval now = ast_tvnow();
02384 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
02385 ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
02386 ast_clear_flag(chan, AST_FLAG_IN_DTMF);
02387 if (!f->len)
02388 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
02389 } else if (!f->len) {
02390 ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
02391 f->len = AST_MIN_DTMF_DURATION;
02392 }
02393 if (f->len < AST_MIN_DTMF_DURATION) {
02394 ast_log(LOG_DTMF, "DTMF end '%c' has duration %ld but want minimum %d, emulating on %s\n", f->subclass, f->len, AST_MIN_DTMF_DURATION, chan->name);
02395 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
02396 chan->emulate_dtmf_digit = f->subclass;
02397 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
02398 f = &ast_null_frame;
02399 } else {
02400 ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
02401 chan->dtmf_tv = now;
02402 }
02403 }
02404 break;
02405 case AST_FRAME_DTMF_BEGIN:
02406 ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
02407 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY) ||
02408 (!ast_tvzero(chan->dtmf_tv) &&
02409 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
02410 ast_frfree(f);
02411 f = &ast_null_frame;
02412 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
02413 } else {
02414 ast_set_flag(chan, AST_FLAG_IN_DTMF);
02415 chan->dtmf_tv = ast_tvnow();
02416 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
02417 }
02418 break;
02419 case AST_FRAME_NULL:
02420 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
02421 struct timeval now = ast_tvnow();
02422 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
02423 chan->emulate_dtmf_duration = 0;
02424 ast_frfree(f);
02425 f = &chan->dtmff;
02426 f->frametype = AST_FRAME_DTMF_END;
02427 f->subclass = chan->emulate_dtmf_digit;
02428 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
02429 chan->dtmf_tv = now;
02430 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
02431 chan->emulate_dtmf_digit = 0;
02432 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
02433 }
02434 }
02435 break;
02436 case AST_FRAME_VOICE:
02437
02438
02439
02440
02441 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
02442 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
02443 chan->emulate_dtmf_digit = 0;
02444 }
02445
02446 if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
02447 if (dropaudio)
02448 ast_read_generator_actions(chan, f);
02449 ast_frfree(f);
02450 f = &ast_null_frame;
02451 }
02452
02453 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
02454 struct timeval now = ast_tvnow();
02455 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
02456 chan->emulate_dtmf_duration = 0;
02457 ast_frfree(f);
02458 f = &chan->dtmff;
02459 f->frametype = AST_FRAME_DTMF_END;
02460 f->subclass = chan->emulate_dtmf_digit;
02461 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
02462 chan->dtmf_tv = now;
02463 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
02464 } else {
02465
02466 ast_frfree(f);
02467 f = &ast_null_frame;
02468 }
02469 } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
02470
02471
02472 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
02473 chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
02474 ast_frame_dump(chan->name, f, "<<");
02475 ast_frfree(f);
02476 f = &ast_null_frame;
02477 } else if ((f->frametype == AST_FRAME_VOICE)) {
02478 if (chan->spies)
02479 queue_frame_to_spies(chan, f, SPY_READ);
02480
02481 if (chan->monitor && chan->monitor->read_stream ) {
02482
02483 #ifndef MONITOR_CONSTANT_DELAY
02484 int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
02485 if (jump >= 0) {
02486 jump = chan->outsmpl - chan->insmpl;
02487 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
02488 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
02489 chan->insmpl += jump + f->samples;
02490 } else
02491 chan->insmpl+= f->samples;
02492 #else
02493 int jump = chan->outsmpl - chan->insmpl;
02494 if (jump - MONITOR_DELAY >= 0) {
02495 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
02496 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
02497 chan->insmpl += jump;
02498 } else
02499 chan->insmpl += f->samples;
02500 #endif
02501 if (chan->monitor->state == AST_MONITOR_RUNNING) {
02502 if (ast_writestream(chan->monitor->read_stream, f) < 0)
02503 ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
02504 }
02505 }
02506
02507 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
02508 f = &ast_null_frame;
02509
02510
02511
02512 ast_read_generator_actions(chan, f);
02513 }
02514 default:
02515
02516 break;
02517 }
02518 } else {
02519
02520 chan->_softhangup |= AST_SOFTHANGUP_DEV;
02521 if (chan->generator)
02522 ast_deactivate_generator(chan);
02523
02524 if (chan->cdr)
02525 ast_cdr_end(chan->cdr);
02526 }
02527
02528
02529 if (chan->fin & DEBUGCHAN_FLAG)
02530 ast_frame_dump(chan->name, f, "<<");
02531 chan->fin = FRAMECOUNT_INC(chan->fin);
02532
02533 done:
02534 ast_channel_unlock(chan);
02535 return f;
02536 }
02537
02538 int ast_internal_timing_enabled(struct ast_channel *chan)
02539 {
02540 int ret = ast_opt_internal_timing && chan->timingfd > -1;
02541 if (option_debug > 4)
02542 ast_log(LOG_DEBUG, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
02543 return ret;
02544 }
02545
02546 struct ast_frame *ast_read(struct ast_channel *chan)
02547 {
02548 return __ast_read(chan, 0);
02549 }
02550
02551 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
02552 {
02553 return __ast_read(chan, 1);
02554 }
02555
02556 int ast_indicate(struct ast_channel *chan, int condition)
02557 {
02558 return ast_indicate_data(chan, condition, NULL, 0);
02559 }
02560
02561 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
02562 {
02563 int res = -1;
02564
02565 ast_channel_lock(chan);
02566
02567 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
02568 ast_channel_unlock(chan);
02569 return -1;
02570 }
02571 if (chan->tech->indicate)
02572 res = chan->tech->indicate(chan, condition, data, datalen);
02573 ast_channel_unlock(chan);
02574 if (!chan->tech->indicate || res) {
02575
02576
02577
02578
02579 if (condition < 0)
02580 ast_playtones_stop(chan);
02581 else {
02582 const struct tone_zone_sound *ts = NULL;
02583 switch (condition) {
02584 case AST_CONTROL_RINGING:
02585 ts = ast_get_indication_tone(chan->zone, "ring");
02586 break;
02587 case AST_CONTROL_BUSY:
02588 ts = ast_get_indication_tone(chan->zone, "busy");
02589 break;
02590 case AST_CONTROL_CONGESTION:
02591 ts = ast_get_indication_tone(chan->zone, "congestion");
02592 break;
02593 }
02594 if (ts && ts->data[0]) {
02595 if (option_debug)
02596 ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
02597 ast_playtones_start(chan,0,ts->data, 1);
02598 res = 0;
02599 } else if (condition == AST_CONTROL_PROGRESS) {
02600
02601 } else if (condition == AST_CONTROL_PROCEEDING) {
02602
02603 } else if (condition == AST_CONTROL_HOLD) {
02604
02605 } else if (condition == AST_CONTROL_UNHOLD) {
02606
02607 } else if (condition == AST_CONTROL_VIDUPDATE) {
02608
02609 } else {
02610
02611 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
02612 res = -1;
02613 }
02614 }
02615 }
02616 return res;
02617 }
02618
02619 int ast_recvchar(struct ast_channel *chan, int timeout)
02620 {
02621 int c;
02622 char *buf = ast_recvtext(chan, timeout);
02623 if (buf == NULL)
02624 return -1;
02625 c = *(unsigned char *)buf;
02626 free(buf);
02627 return c;
02628 }
02629
02630 char *ast_recvtext(struct ast_channel *chan, int timeout)
02631 {
02632 int res, done = 0;
02633 char *buf = NULL;
02634
02635 while (!done) {
02636 struct ast_frame *f;
02637 if (ast_check_hangup(chan))
02638 break;
02639 res = ast_waitfor(chan, timeout);
02640 if (res <= 0)
02641 break;
02642 timeout = res;
02643 f = ast_read(chan);
02644 if (f == NULL)
02645 break;
02646 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
02647 done = 1;
02648 else if (f->frametype == AST_FRAME_TEXT) {
02649 buf = ast_strndup((char *) f->data, f->datalen);
02650 done = 1;
02651 }
02652 ast_frfree(f);
02653 }
02654 return buf;
02655 }
02656
02657 int ast_sendtext(struct ast_channel *chan, const char *text)
02658 {
02659 int res = 0;
02660
02661 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
02662 return -1;
02663 CHECK_BLOCKING(chan);
02664 if (chan->tech->send_text)
02665 res = chan->tech->send_text(chan, text);
02666 ast_clear_flag(chan, AST_FLAG_BLOCKING);
02667 return res;
02668 }
02669
02670 int ast_senddigit_begin(struct ast_channel *chan, char digit)
02671 {
02672
02673
02674 static const char* dtmf_tones[] = {
02675 "941+1336",
02676 "697+1209",
02677 "697+1336",
02678 "697+1477",
02679 "770+1209",
02680 "770+1336",
02681 "770+1477",
02682 "852+1209",
02683 "852+1336",
02684 "852+1477",
02685 "697+1633",
02686 "770+1633",
02687 "852+1633",
02688 "941+1633",
02689 "941+1209",
02690 "941+1477"
02691 };
02692
02693 if (!chan->tech->send_digit_begin)
02694 return 0;
02695
02696 if (!chan->tech->send_digit_begin(chan, digit))
02697 return 0;
02698
02699 if (digit >= '0' && digit <='9')
02700 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
02701 else if (digit >= 'A' && digit <= 'D')
02702 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
02703 else if (digit == '*')
02704 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
02705 else if (digit == '#')
02706 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
02707 else {
02708
02709 if (option_debug)
02710 ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
02711 }
02712
02713 return 0;
02714 }
02715
02716 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
02717 {
02718 int res = -1;
02719
02720 if (chan->tech->send_digit_end)
02721 res = chan->tech->send_digit_end(chan, digit, duration);
02722
02723 if (res && chan->generator)
02724 ast_playtones_stop(chan);
02725
02726 return 0;
02727 }
02728
02729 int ast_senddigit(struct ast_channel *chan, char digit)
02730 {
02731 if (chan->tech->send_digit_begin) {
02732 ast_senddigit_begin(chan, digit);
02733 ast_safe_sleep(chan, AST_DEFAULT_EMULATE_DTMF_DURATION);
02734 }
02735
02736 return ast_senddigit_end(chan, digit, AST_DEFAULT_EMULATE_DTMF_DURATION);
02737 }
02738
02739 int ast_prod(struct ast_channel *chan)
02740 {
02741 struct ast_frame a = { AST_FRAME_VOICE };
02742 char nothing[128];
02743
02744
02745 if (chan->_state != AST_STATE_UP) {
02746 if (option_debug)
02747 ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
02748 a.subclass = chan->rawwriteformat;
02749 a.data = nothing + AST_FRIENDLY_OFFSET;
02750 a.src = "ast_prod";
02751 if (ast_write(chan, &a))
02752 ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
02753 }
02754 return 0;
02755 }
02756
02757 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
02758 {
02759 int res;
02760 if (!chan->tech->write_video)
02761 return 0;
02762 res = ast_write(chan, fr);
02763 if (!res)
02764 res = 1;
02765 return res;
02766 }
02767
02768 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
02769 {
02770 int res = -1;
02771 struct ast_frame *f = NULL;
02772
02773
02774 ast_channel_lock(chan);
02775 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
02776 goto done;
02777
02778
02779 if (chan->masq && ast_do_masquerade(chan)) {
02780 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
02781 goto done;
02782 }
02783 if (chan->masqr) {
02784 res = 0;
02785 goto done;
02786 }
02787 if (chan->generatordata) {
02788 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
02789 ast_deactivate_generator(chan);
02790 else {
02791 if (fr->frametype == AST_FRAME_DTMF_END) {
02792
02793
02794
02795 ast_clear_flag(chan, AST_FLAG_BLOCKING);
02796 ast_channel_unlock(chan);
02797 res = ast_senddigit_end(chan, fr->subclass, fr->len);
02798 ast_channel_lock(chan);
02799 CHECK_BLOCKING(chan);
02800 } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
02801
02802 res = (chan->tech->indicate == NULL) ? 0 :
02803 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
02804 }
02805 res = 0;
02806 goto done;
02807 }
02808 }
02809
02810 if (chan->fout & DEBUGCHAN_FLAG)
02811 ast_frame_dump(chan->name, fr, ">>");
02812 CHECK_BLOCKING(chan);
02813 switch(fr->frametype) {
02814 case AST_FRAME_CONTROL:
02815 res = (chan->tech->indicate == NULL) ? 0 :
02816 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
02817 break;
02818 case AST_FRAME_DTMF_BEGIN:
02819 ast_clear_flag(chan, AST_FLAG_BLOCKING);
02820 ast_channel_unlock(chan);
02821 res = ast_senddigit_begin(chan, fr->subclass);
02822 ast_channel_lock(chan);
02823 CHECK_BLOCKING(chan);
02824 break;
02825 case AST_FRAME_DTMF_END:
02826 ast_clear_flag(chan, AST_FLAG_BLOCKING);
02827 ast_channel_unlock(chan);
02828 res = ast_senddigit_end(chan, fr->subclass, fr->len);
02829 ast_channel_lock(chan);
02830 CHECK_BLOCKING(chan);
02831 break;
02832 case AST_FRAME_TEXT:
02833 res = (chan->tech->send_text == NULL) ? 0 :
02834 chan->tech->send_text(chan, (char *) fr->data);
02835 break;
02836 case AST_FRAME_HTML:
02837 res = (chan->tech->send_html == NULL) ? 0 :
02838 chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
02839 break;
02840 case AST_FRAME_VIDEO:
02841
02842 res = (chan->tech->write_video == NULL) ? 0 :
02843 chan->tech->write_video(chan, fr);
02844 break;
02845 case AST_FRAME_MODEM:
02846 res = (chan->tech->write == NULL) ? 0 :
02847 chan->tech->write(chan, fr);
02848 break;
02849 case AST_FRAME_VOICE:
02850 if (chan->tech->write == NULL)
02851 break;
02852
02853
02854 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
02855 if (fr->subclass == AST_FORMAT_SLINEAR)
02856 f = fr;
02857 else {
02858 ast_mutex_lock(&chan->whisper->lock);
02859 if (chan->writeformat != AST_FORMAT_SLINEAR) {
02860
02861 chan->whisper->original_format = chan->writeformat;
02862 ast_set_write_format(chan, AST_FORMAT_SLINEAR);
02863 if (chan->whisper->path)
02864 ast_translator_free_path(chan->whisper->path);
02865 chan->whisper->path = ast_translator_build_path(AST_FORMAT_SLINEAR, chan->whisper->original_format);
02866 }
02867
02868 f = (chan->whisper->path) ? ast_translate(chan->whisper->path, fr, 0) : fr;
02869 ast_mutex_unlock(&chan->whisper->lock);
02870 }
02871 } else {
02872
02873 if (fr->subclass == chan->rawwriteformat)
02874 f = fr;
02875 else
02876 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
02877 }
02878
02879
02880 if (f == NULL) {
02881 res = 0;
02882 break;
02883 }
02884
02885
02886 if (chan->spies)
02887 queue_frame_to_spies(chan, f, SPY_WRITE);
02888
02889
02890 if (chan->monitor && chan->monitor->write_stream) {
02891
02892 #ifndef MONITOR_CONSTANT_DELAY
02893 int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
02894 if (jump >= 0) {
02895 jump = chan->insmpl - chan->outsmpl;
02896 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
02897 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
02898 chan->outsmpl += jump + f->samples;
02899 } else
02900 chan->outsmpl += f->samples;
02901 #else
02902 int jump = chan->insmpl - chan->outsmpl;
02903 if (jump - MONITOR_DELAY >= 0) {
02904 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
02905 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
02906 chan->outsmpl += jump;
02907 } else
02908 chan->outsmpl += f->samples;
02909 #endif
02910 if (chan->monitor->state == AST_MONITOR_RUNNING) {
02911 if (ast_writestream(chan->monitor->write_stream, f) < 0)
02912 ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
02913 }
02914 }
02915
02916
02917 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
02918
02919
02920 ast_frame_adjust_volume(f, -2);
02921 if (ast_slinfactory_available(&chan->whisper->sf) >= f->samples) {
02922 short buf[f->samples];
02923 struct ast_frame whisper = {
02924 .frametype = AST_FRAME_VOICE,
02925 .subclass = AST_FORMAT_SLINEAR,
02926 .data = buf,
02927 .datalen = sizeof(buf),
02928 .samples = f->samples,
02929 };
02930
02931 ast_mutex_lock(&chan->whisper->lock);
02932 if (ast_slinfactory_read(&chan->whisper->sf, buf, f->samples))
02933 ast_frame_slinear_sum(f, &whisper);
02934 ast_mutex_unlock(&chan->whisper->lock);
02935 }
02936
02937 f = (chan->writetrans) ? ast_translate(chan->writetrans, f, 0) : f;
02938 }
02939 if (f)
02940 res = chan->tech->write(chan, f);
02941 else
02942 res = 0;
02943 break;
02944 case AST_FRAME_NULL:
02945 case AST_FRAME_IAX:
02946
02947 res = 0;
02948 break;
02949 default:
02950
02951
02952
02953 res = chan->tech->write(chan, fr);
02954 break;
02955 }
02956
02957 if (f && f != fr)
02958 ast_frfree(f);
02959 ast_clear_flag(chan, AST_FLAG_BLOCKING);
02960
02961 if (res < 0)
02962 chan->_softhangup |= AST_SOFTHANGUP_DEV;
02963 else {
02964 chan->fout = FRAMECOUNT_INC(chan->fout);
02965 }
02966 done:
02967 ast_channel_unlock(chan);
02968 return res;
02969 }
02970
02971 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
02972 struct ast_trans_pvt **trans, const int direction)
02973 {
02974 int native;
02975 int res;
02976
02977
02978 fmt &= AST_FORMAT_AUDIO_MASK;
02979
02980 native = chan->nativeformats;
02981
02982 if (!direction)
02983
02984 res = ast_translator_best_choice(&fmt, &native);
02985 else
02986
02987 res = ast_translator_best_choice(&native, &fmt);
02988
02989 if (res < 0) {
02990 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
02991 ast_getformatname(native), ast_getformatname(fmt));
02992 return -1;
02993 }
02994
02995
02996 ast_channel_lock(chan);
02997
02998 if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
02999
03000 ast_channel_unlock(chan);
03001 return 0;
03002 }
03003
03004 *rawformat = native;
03005
03006 *format = fmt;
03007
03008 if (*trans)
03009 ast_translator_free_path(*trans);
03010
03011 if (!direction)
03012
03013 *trans = ast_translator_build_path(*format, *rawformat);
03014 else
03015
03016 *trans = ast_translator_build_path(*rawformat, *format);
03017 ast_channel_unlock(chan);
03018 if (option_debug)
03019 ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
03020 direction ? "write" : "read", ast_getformatname(fmt));
03021 return 0;
03022 }
03023
03024 int ast_set_read_format(struct ast_channel *chan, int fmt)
03025 {
03026 return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
03027 &chan->readtrans, 0);
03028 }
03029
03030 int ast_set_write_format(struct ast_channel *chan, int fmt)
03031 {
03032 return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
03033 &chan->writetrans, 1);
03034 }
03035
03036 char *ast_channel_reason2str(int reason)
03037 {
03038 switch (reason)
03039 {
03040 case 0:
03041 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
03042 case AST_CONTROL_HANGUP:
03043 return "Hangup";
03044 case AST_CONTROL_RING:
03045 return "Local Ring";
03046 case AST_CONTROL_RINGING:
03047 return "Remote end Ringing";
03048 case AST_CONTROL_ANSWER:
03049 return "Remote end has Answered";
03050 case AST_CONTROL_BUSY:
03051 return "Remote end is Busy";
03052 case AST_CONTROL_CONGESTION:
03053 return "Congestion (circuits busy)";
03054 default:
03055 return "Unknown Reason!!";
03056 }
03057 }
03058
03059 struct ast_channel *__ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
03060 {
03061 int dummy_outstate;
03062 int cause = 0;
03063 struct ast_channel *chan;
03064 int res = 0;
03065
03066 if (outstate)
03067 *outstate = 0;
03068 else
03069 outstate = &dummy_outstate;
03070
03071 chan = ast_request(type, format, data, &cause);
03072 if (!chan) {
03073 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
03074
03075 if (cause == AST_CAUSE_BUSY)
03076 *outstate = AST_CONTROL_BUSY;
03077 else if (cause == AST_CAUSE_CONGESTION)
03078 *outstate = AST_CONTROL_CONGESTION;
03079 return NULL;
03080 }
03081
03082 if (oh) {
03083 if (oh->vars)
03084 ast_set_variables(chan, oh->vars);
03085
03086 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
03087 ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
03088 if (oh->parent_channel)
03089 ast_channel_inherit_variables(oh->parent_channel, chan);
03090 if (oh->account)
03091 ast_cdr_setaccount(chan, oh->account);
03092 }
03093 ast_set_callerid(chan, cid_num, cid_name, cid_num);
03094
03095
03096
03097 if (!chan->cdr) {
03098
03099
03100 chan->cdr = ast_cdr_alloc();
03101 ast_cdr_init(chan->cdr, chan);
03102 ast_cdr_start(chan->cdr);
03103 }
03104 if (ast_call(chan, data, 0)) {
03105 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
03106 } else {
03107 res = 1;
03108 while (timeout && chan->_state != AST_STATE_UP) {
03109 struct ast_frame *f;
03110 res = ast_waitfor(chan, timeout);
03111 if (res <= 0)
03112 break;
03113 if (timeout > -1)
03114 timeout = res;
03115 f = ast_read(chan);
03116 if (!f) {
03117 *outstate = AST_CONTROL_HANGUP;
03118 res = 0;
03119 break;
03120 }
03121 if (f->frametype == AST_FRAME_CONTROL) {
03122 switch (f->subclass) {
03123 case AST_CONTROL_RINGING:
03124 *outstate = f->subclass;
03125 break;
03126
03127 case AST_CONTROL_BUSY:
03128 case AST_CONTROL_CONGESTION:
03129 case AST_CONTROL_ANSWER:
03130 *outstate = f->subclass;
03131 timeout = 0;
03132 break;
03133
03134
03135 case AST_CONTROL_PROGRESS:
03136 case AST_CONTROL_PROCEEDING:
03137 case AST_CONTROL_HOLD:
03138 case AST_CONTROL_UNHOLD:
03139 case AST_CONTROL_VIDUPDATE:
03140 case -1:
03141 break;
03142
03143 default:
03144 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
03145 }
03146 }
03147 ast_frfree(f);
03148 }
03149 }
03150
03151
03152 if (oh) {
03153 if (!ast_strlen_zero(oh->context))
03154 ast_copy_string(chan->context, oh->context, sizeof(chan->context));
03155 if (!ast_strlen_zero(oh->exten))
03156 ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
03157 if (oh->priority)
03158 chan->priority = oh->priority;
03159 }
03160 if (chan->_state == AST_STATE_UP)
03161 *outstate = AST_CONTROL_ANSWER;
03162
03163 if (res <= 0) {
03164 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
03165 ast_cdr_init(chan->cdr, chan);
03166 if (chan->cdr) {
03167 char tmp[256];
03168 snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
03169 ast_cdr_setapp(chan->cdr,"Dial",tmp);
03170 ast_cdr_update(chan);
03171 ast_cdr_start(chan->cdr);
03172 ast_cdr_end(chan->cdr);
03173
03174 if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
03175 ast_cdr_failed(chan->cdr);
03176 }
03177 ast_hangup(chan);
03178 chan = NULL;
03179 }
03180 return chan;
03181 }
03182
03183 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
03184 {
03185 return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
03186 }
03187
03188 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
03189 {
03190 struct chanlist *chan;
03191 struct ast_channel *c;
03192 int capabilities;
03193 int fmt;
03194 int res;
03195 int foo;
03196 int videoformat = format & AST_FORMAT_VIDEO_MASK;
03197
03198 if (!cause)
03199 cause = &foo;
03200 *cause = AST_CAUSE_NOTDEFINED;
03201
03202 if (AST_LIST_LOCK(&channels)) {
03203 ast_log(LOG_WARNING, "Unable to lock channel list\n");
03204 return NULL;
03205 }
03206
03207 AST_LIST_TRAVERSE(&backends, chan, list) {
03208 if (strcasecmp(type, chan->tech->type))
03209 continue;
03210
03211 capabilities = chan->tech->capabilities;
03212 fmt = format & AST_FORMAT_AUDIO_MASK;
03213 res = ast_translator_best_choice(&fmt, &capabilities);
03214 if (res < 0) {
03215 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->tech->capabilities, format);
03216 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03217 AST_LIST_UNLOCK(&channels);
03218 return NULL;
03219 }
03220 AST_LIST_UNLOCK(&channels);
03221 if (!chan->tech->requester)
03222 return NULL;
03223
03224 if (!(c = chan->tech->requester(type, capabilities | videoformat, data, cause)))
03225 return NULL;
03226
03227
03228 return c;
03229 }
03230
03231 ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
03232 *cause = AST_CAUSE_NOSUCHDRIVER;
03233 AST_LIST_UNLOCK(&channels);
03234
03235 return NULL;
03236 }
03237
03238 int ast_call(struct ast_channel *chan, char *addr, int timeout)
03239 {
03240
03241
03242
03243 int res = -1;
03244
03245 ast_channel_lock(chan);
03246 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
03247 if (chan->tech->call)
03248 res = chan->tech->call(chan, addr, timeout);
03249 ast_set_flag(chan, AST_FLAG_OUTGOING);
03250 }
03251 ast_channel_unlock(chan);
03252 return res;
03253 }
03254
03255
03256
03257
03258
03259
03260
03261
03262 int ast_transfer(struct ast_channel *chan, char *dest)
03263 {
03264 int res = -1;
03265
03266
03267 ast_channel_lock(chan);
03268 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
03269 if (chan->tech->transfer) {
03270 res = chan->tech->transfer(chan, dest);
03271 if (!res)
03272 res = 1;
03273 } else
03274 res = 0;
03275 }
03276 ast_channel_unlock(chan);
03277 return res;
03278 }
03279
03280 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
03281 {
03282 return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
03283 }
03284
03285 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
03286 {
03287 int pos = 0;
03288 int to = ftimeout;
03289
03290
03291 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
03292 return -1;
03293 if (!len)
03294 return -1;
03295 for (;;) {
03296 int d;
03297 if (c->stream) {
03298 d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
03299 ast_stopstream(c);
03300 usleep(1000);
03301 if (!d)
03302 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
03303 } else {
03304 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
03305 }
03306 if (d < 0)
03307 return -1;
03308 if (d == 0) {
03309 s[pos]='\0';
03310 return 1;
03311 }
03312 if (d == 1) {
03313 s[pos]='\0';
03314 return 2;
03315 }
03316 if (!strchr(enders, d))
03317 s[pos++] = d;
03318 if (strchr(enders, d) || (pos >= len)) {
03319 s[pos]='\0';
03320 return 0;
03321 }
03322 to = timeout;
03323 }
03324
03325 return 0;
03326 }
03327
03328 int ast_channel_supports_html(struct ast_channel *chan)
03329 {
03330 return (chan->tech->send_html) ? 1 : 0;
03331 }
03332
03333 int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
03334 {
03335 if (chan->tech->send_html)
03336 return chan->tech->send_html(chan, subclass, data, datalen);
03337 return -1;
03338 }
03339
03340 int ast_channel_sendurl(struct ast_channel *chan, const char *url)
03341 {
03342 return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
03343 }
03344
03345 int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
03346 {
03347 int src;
03348 int dst;
03349
03350 if (chan->readformat == peer->writeformat && chan->writeformat == peer->readformat) {
03351
03352 return 0;
03353 }
03354
03355
03356 src = chan->nativeformats;
03357 dst = peer->nativeformats;
03358 if (ast_translator_best_choice(&dst, &src) < 0) {
03359 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, src, peer->name, dst);
03360 return -1;
03361 }
03362
03363
03364
03365
03366
03367 if ((src != dst) && ast_opt_transcode_via_slin &&
03368 (ast_translate_path_steps(dst, src) != 1))
03369 dst = AST_FORMAT_SLINEAR;
03370 if (ast_set_read_format(chan, dst) < 0) {
03371 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, dst);
03372 return -1;
03373 }
03374 if (ast_set_write_format(peer, dst) < 0) {
03375 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, dst);
03376 return -1;
03377 }
03378
03379
03380 src = peer->nativeformats;
03381 dst = chan->nativeformats;
03382 if (ast_translator_best_choice(&dst, &src) < 0) {
03383 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, src, chan->name, dst);
03384 return -1;
03385 }
03386
03387
03388
03389
03390
03391 if ((src != dst) && ast_opt_transcode_via_slin &&
03392 (ast_translate_path_steps(dst, src) != 1))
03393 dst = AST_FORMAT_SLINEAR;
03394 if (ast_set_read_format(peer, dst) < 0) {
03395 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, dst);
03396 return -1;
03397 }
03398 if (ast_set_write_format(chan, dst) < 0) {
03399 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, dst);
03400 return -1;
03401 }
03402 return 0;
03403 }
03404
03405 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone)
03406 {
03407 int res = -1;
03408 struct ast_channel *final_orig = original, *final_clone = clone;
03409
03410 ast_channel_lock(original);
03411 while (ast_channel_trylock(clone)) {
03412 ast_channel_unlock(original);
03413 usleep(1);
03414 ast_channel_lock(original);
03415 }
03416
03417
03418
03419 if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
03420 final_orig = original->_bridge;
03421
03422 if (clone->_bridge && (clone->_bridge != ast_bridged_channel(clone)) && (clone->_bridge->_bridge != clone))
03423 final_clone = clone->_bridge;
03424
03425 if ((final_orig != original) || (final_clone != clone)) {
03426 ast_channel_lock(final_orig);
03427 while (ast_channel_trylock(final_clone)) {
03428 ast_channel_unlock(final_orig);
03429 usleep(1);
03430 ast_channel_lock(final_orig);
03431 }
03432 ast_channel_unlock(clone);
03433 ast_channel_unlock(original);
03434 original = final_orig;
03435 clone = final_clone;
03436 }
03437
03438 if (original == clone) {
03439 ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
03440 ast_channel_unlock(clone);
03441 ast_channel_unlock(original);
03442 return -1;
03443 }
03444
03445 if (option_debug)
03446 ast_log(LOG_DEBUG, "Planning to masquerade channel %s into the structure of %s\n",
03447 clone->name, original->name);
03448 if (original->masq) {
03449 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
03450 original->masq->name, original->name);
03451 } else if (clone->masqr) {
03452 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
03453 clone->name, clone->masqr->name);
03454 } else {
03455 original->masq = clone;
03456 clone->masqr = original;
03457 ast_queue_frame(original, &ast_null_frame);
03458 ast_queue_frame(clone, &ast_null_frame);
03459 if (option_debug)
03460 ast_log(LOG_DEBUG, "Done planning to masquerade channel %s into the structure of %s\n", clone->name, original->name);
03461 res = 0;
03462 }
03463
03464 ast_channel_unlock(clone);
03465 ast_channel_unlock(original);
03466
03467 return res;
03468 }
03469
03470 void ast_change_name(struct ast_channel *chan, char *newname)
03471 {
03472 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
03473 ast_string_field_set(chan, name, newname);
03474 }
03475
03476 void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
03477 {
03478 struct ast_var_t *current, *newvar;
03479 const char *varname;
03480
03481 AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
03482 int vartype = 0;
03483
03484 varname = ast_var_full_name(current);
03485 if (!varname)
03486 continue;
03487
03488 if (varname[0] == '_') {
03489 vartype = 1;
03490 if (varname[1] == '_')
03491 vartype = 2;
03492 }
03493
03494 switch (vartype) {
03495 case 1:
03496 newvar = ast_var_assign(&varname[1], ast_var_value(current));
03497 if (newvar) {
03498 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
03499 if (option_debug)
03500 ast_log(LOG_DEBUG, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
03501 }
03502 break;
03503 case 2:
03504 newvar = ast_var_assign(ast_var_full_name(current), ast_var_value(current));
03505 if (newvar) {
03506 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
03507 if (option_debug)
03508 ast_log(LOG_DEBUG, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
03509 }
03510 break;
03511 default:
03512 if (option_debug)
03513 ast_log(LOG_DEBUG, "Not copying variable %s.\n", ast_var_name(current));
03514 break;
03515 }
03516 }
03517 }
03518
03519
03520
03521
03522
03523
03524
03525
03526
03527
03528 static void clone_variables(struct ast_channel *original, struct ast_channel *clone)
03529 {
03530 struct ast_var_t *current, *newvar;
03531
03532
03533 if (AST_LIST_FIRST(&clone->varshead))
03534 AST_LIST_APPEND_LIST(&original->varshead, &clone->varshead, entries);
03535 AST_LIST_HEAD_INIT_NOLOCK(&clone->varshead);
03536
03537
03538
03539 AST_LIST_TRAVERSE(&original->varshead, current, entries) {
03540 newvar = ast_var_assign(current->name, current->value);
03541 if (newvar)
03542 AST_LIST_INSERT_TAIL(&clone->varshead, newvar, entries);
03543 }
03544 }
03545
03546
03547
03548
03549
03550
03551 int ast_do_masquerade(struct ast_channel *original)
03552 {
03553 int x,i;
03554 int res=0;
03555 int origstate;
03556 struct ast_frame *cur;
03557 const struct ast_channel_tech *t;
03558 void *t_pvt;
03559 struct ast_callerid tmpcid;
03560 struct ast_channel *clone = original->masq;
03561 struct ast_channel_spy_list *spy_list = NULL;
03562 struct ast_channel_spy *spy = NULL;
03563 struct ast_cdr *cdr;
03564 int rformat = original->readformat;
03565 int wformat = original->writeformat;
03566 char newn[100];
03567 char orig[100];
03568 char masqn[100];
03569 char zombn[100];
03570
03571 if (option_debug > 3)
03572 ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
03573 clone->name, clone->_state, original->name, original->_state);
03574
03575
03576
03577
03578
03579
03580
03581 ast_channel_lock(clone);
03582
03583 if (option_debug > 1)
03584 ast_log(LOG_DEBUG, "Got clone lock for masquerade on '%s' at %p\n", clone->name, &clone->lock);
03585
03586
03587
03588 free_translation(clone);
03589 free_translation(original);
03590
03591
03592
03593 original->masq = NULL;
03594 clone->masqr = NULL;
03595
03596
03597 ast_copy_string(orig, original->name, sizeof(orig));
03598
03599 ast_copy_string(newn, clone->name, sizeof(newn));
03600
03601 snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
03602
03603
03604 ast_string_field_set(original, name, newn);
03605
03606
03607 ast_string_field_set(clone, name, masqn);
03608
03609
03610 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clone->uniqueid);
03611 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid);
03612
03613
03614 t = original->tech;
03615 original->tech = clone->tech;
03616 clone->tech = t;
03617
03618
03619 cdr = original->cdr;
03620 original->cdr = clone->cdr;
03621 clone->cdr = cdr;
03622
03623 t_pvt = original->tech_pvt;
03624 original->tech_pvt = clone->tech_pvt;
03625 clone->tech_pvt = t_pvt;
03626
03627
03628 cur = AST_LIST_FIRST(&original->readq);
03629 AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
03630 AST_LIST_HEAD_SET_NOLOCK(&clone->readq, cur);
03631
03632
03633 for (i = 0; i < 2; i++) {
03634 x = original->alertpipe[i];
03635 original->alertpipe[i] = clone->alertpipe[i];
03636 clone->alertpipe[i] = x;
03637 }
03638
03639
03640 x = original->rawreadformat;
03641 original->rawreadformat = clone->rawreadformat;
03642 clone->rawreadformat = x;
03643 x = original->rawwriteformat;
03644 original->rawwriteformat = clone->rawwriteformat;
03645 clone->rawwriteformat = x;
03646
03647
03648 spy_list = original->spies;
03649 original->spies = clone->spies;
03650 clone->spies = spy_list;
03651
03652
03653 if (original->spies) {
03654 AST_LIST_TRAVERSE(&original->spies->list, spy, list) {
03655 ast_mutex_lock(&spy->lock);
03656 spy->chan = original;
03657 ast_mutex_unlock(&spy->lock);
03658 }
03659 }
03660 if (clone->spies) {
03661 AST_LIST_TRAVERSE(&clone->spies->list, spy, list) {
03662 ast_mutex_lock(&spy->lock);
03663 spy->chan = clone;
03664 ast_mutex_unlock(&spy->lock);
03665 }
03666 }
03667
03668
03669
03670 x = 0;
03671 if (original->alertpipe[1] > -1) {
03672 AST_LIST_TRAVERSE(&clone->readq, cur, frame_list)
03673 x++;
03674 }
03675
03676
03677
03678 if (AST_LIST_FIRST(&clone->readq)) {
03679 AST_LIST_INSERT_TAIL(&clone->readq, AST_LIST_FIRST(&original->readq), frame_list);
03680 AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
03681 AST_LIST_HEAD_SET_NOLOCK(&clone->readq, NULL);
03682 for (i = 0; i < x; i++)
03683 write(original->alertpipe[1], &x, sizeof(x));
03684 }
03685
03686 clone->_softhangup = AST_SOFTHANGUP_DEV;
03687
03688
03689
03690
03691
03692
03693 origstate = original->_state;
03694 original->_state = clone->_state;
03695 clone->_state = origstate;
03696
03697 if (clone->tech->fixup){
03698 res = clone->tech->fixup(original, clone);
03699 if (res)
03700 ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clone->name);
03701 }
03702
03703
03704 if (clone->tech->hangup)
03705 res = clone->tech->hangup(clone);
03706 if (res) {
03707 ast_log(LOG_WARNING, "Hangup failed! Strange things may happen!\n");
03708 ast_channel_unlock(clone);
03709 return -1;
03710 }
03711
03712 snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig);
03713
03714 ast_string_field_set(clone, name, zombn);
03715 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clone->uniqueid);
03716
03717
03718 t_pvt = original->monitor;
03719 original->monitor = clone->monitor;
03720 clone->monitor = t_pvt;
03721
03722
03723 ast_string_field_set(original, language, clone->language);
03724
03725 for (x = 0; x < AST_MAX_FDS; x++) {
03726 if (x != AST_GENERATOR_FD)
03727 original->fds[x] = clone->fds[x];
03728 }
03729
03730 ast_app_group_update(clone, original);
03731
03732
03733 ast_channel_whisper_stop(original);
03734 if (ast_test_flag(clone, AST_FLAG_WHISPER)) {
03735 original->whisper = clone->whisper;
03736 ast_set_flag(original, AST_FLAG_WHISPER);
03737 clone->whisper = NULL;
03738 ast_clear_flag(clone, AST_FLAG_WHISPER);
03739 }
03740
03741
03742 if (AST_LIST_FIRST(&clone->datastores))
03743 AST_LIST_INSERT_TAIL(&original->datastores, AST_LIST_FIRST(&clone->datastores), entry);
03744 AST_LIST_HEAD_INIT_NOLOCK(&clone->datastores);
03745
03746 clone_variables(original, clone);
03747
03748 original->adsicpe = clone->adsicpe;
03749
03750
03751
03752
03753
03754 ast_copy_flags(original, clone, AST_FLAG_EXCEPTION);
03755 original->fdno = clone->fdno;
03756
03757
03758
03759
03760
03761
03762 tmpcid = original->cid;
03763 original->cid = clone->cid;
03764 clone->cid = tmpcid;
03765
03766
03767 original->fds[AST_TIMING_FD] = original->timingfd;
03768
03769
03770 original->nativeformats = clone->nativeformats;
03771
03772
03773
03774
03775
03776 ast_set_write_format(original, wformat);
03777
03778
03779 ast_set_read_format(original, rformat);
03780
03781
03782 ast_string_field_set(original, musicclass, clone->musicclass);
03783
03784 if (option_debug)
03785 ast_log(LOG_DEBUG, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat);
03786
03787
03788
03789 if (original->tech->fixup) {
03790 res = original->tech->fixup(clone, original);
03791 if (res) {
03792 ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n",
03793 original->tech->type, original->name);
03794 ast_channel_unlock(clone);
03795 return -1;
03796 }
03797 } else
03798 ast_log(LOG_WARNING, "Channel type '%s' does not have a fixup routine (for %s)! Bad things may happen.\n",
03799 original->tech->type, original->name);
03800
03801
03802
03803
03804 if (ast_test_flag(clone, AST_FLAG_ZOMBIE)) {
03805 if (option_debug)
03806 ast_log(LOG_DEBUG, "Destroying channel clone '%s'\n", clone->name);
03807 ast_channel_unlock(clone);
03808 manager_event(EVENT_FLAG_CALL, "Hangup",
03809 "Channel: %s\r\n"
03810 "Uniqueid: %s\r\n"
03811 "Cause: %d\r\n"
03812 "Cause-txt: %s\r\n",
03813 clone->name,
03814 clone->uniqueid,
03815 clone->hangupcause,
03816 ast_cause2str(clone->hangupcause)
03817 );
03818 ast_channel_free(clone);
03819 } else {
03820 if (option_debug)
03821 ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name);
03822 ast_set_flag(clone, AST_FLAG_ZOMBIE);
03823 ast_queue_frame(clone, &ast_null_frame);
03824 ast_channel_unlock(clone);
03825 }
03826
03827
03828 if (ast_test_flag(original, AST_FLAG_BLOCKING))
03829 pthread_kill(original->blocker, SIGURG);
03830 if (option_debug)
03831 ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n", original->name, original->_state);
03832 return 0;
03833 }
03834
03835 void ast_set_callerid(struct ast_channel *chan, const char *callerid, const char *calleridname, const char *ani)
03836 {
03837 if (callerid) {
03838 if (chan->cid.cid_num)
03839 free(chan->cid.cid_num);
03840 chan->cid.cid_num = ast_strdup(callerid);
03841 }
03842 if (calleridname) {
03843 if (chan->cid.cid_name)
03844 free(chan->cid.cid_name);
03845 chan->cid.cid_name = ast_strdup(calleridname);
03846 }
03847 if (ani) {
03848 if (chan->cid.cid_ani)
03849 free(chan->cid.cid_ani);
03850 chan->cid.cid_ani = ast_strdup(ani);
03851 }
03852 if (chan->cdr)
03853 ast_cdr_setcid(chan->cdr, chan);
03854 manager_event(EVENT_FLAG_CALL, "Newcallerid",
03855 "Channel: %s\r\n"
03856 "CallerID: %s\r\n"
03857 "CallerIDName: %s\r\n"
03858 "Uniqueid: %s\r\n"
03859 "CID-CallingPres: %d (%s)\r\n",
03860 chan->name,
03861 S_OR(chan->cid.cid_num, "<Unknown>"),
03862 S_OR(chan->cid.cid_name, "<Unknown>"),
03863 chan->uniqueid,
03864 chan->cid.cid_pres,
03865 ast_describe_caller_presentation(chan->cid.cid_pres)
03866 );
03867 }
03868
03869 int ast_setstate(struct ast_channel *chan, enum ast_channel_state state)
03870 {
03871 int oldstate = chan->_state;
03872
03873 if (oldstate == state)
03874 return 0;
03875
03876 chan->_state = state;
03877 ast_device_state_changed_literal(chan->name);
03878
03879 manager_event(EVENT_FLAG_CALL,
03880 "Newstate",
03881 "Channel: %s\r\n"
03882 "State: %s\r\n"
03883 "CallerID: %s\r\n"
03884 "CallerIDName: %s\r\n"
03885 "Uniqueid: %s\r\n",
03886 chan->name, ast_state2str(chan->_state),
03887 S_OR(chan->cid.cid_num, "<unknown>"),
03888 S_OR(chan->cid.cid_name, "<unknown>"),
03889 chan->uniqueid);
03890
03891 return 0;
03892 }
03893
03894
03895 struct ast_channel *ast_bridged_channel(struct ast_channel *chan)
03896 {
03897 struct ast_channel *bridged;
03898 bridged = chan->_bridge;
03899 if (bridged && bridged->tech->bridged_channel)
03900 bridged = bridged->tech->bridged_channel(chan, bridged);
03901 return bridged;
03902 }
03903
03904 static void bridge_playfile(struct ast_channel *chan, struct ast_channel *peer, const char *sound, int remain)
03905 {
03906 int min = 0, sec = 0, check;
03907
03908 check = ast_autoservice_start(peer);
03909 if (check)
03910 return;
03911
03912 if (remain > 0) {
03913 if (remain / 60 > 1) {
03914 min = remain / 60;
03915 sec = remain % 60;
03916 } else {
03917 sec = remain;
03918 }
03919 }
03920
03921 if (!strcmp(sound,"timeleft")) {
03922 ast_stream_and_wait(chan, "vm-youhave", chan->language, "");
03923 if (min) {
03924 ast_say_number(chan, min, AST_DIGIT_ANY, chan->language, NULL);
03925 ast_stream_and_wait(chan, "queue-minutes", chan->language, "");
03926 }
03927 if (sec) {
03928 ast_say_number(chan, sec, AST_DIGIT_ANY, chan->language, NULL);
03929 ast_stream_and_wait(chan, "queue-seconds", chan->language, "");
03930 }
03931 } else {
03932 ast_stream_and_wait(chan, sound, chan->language, "");
03933 }
03934
03935 ast_autoservice_stop(peer);
03936 }
03937
03938 static enum ast_bridge_result ast_generic_bridge(struct ast_channel *c0, struct ast_channel *c1,
03939 struct ast_bridge_config *config, struct ast_frame **fo,
03940 struct ast_channel **rc, struct timeval bridge_end)
03941 {
03942
03943 struct ast_channel *cs[3];
03944 struct ast_frame *f;
03945 enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
03946 int o0nativeformats;
03947 int o1nativeformats;
03948 int watch_c0_dtmf;
03949 int watch_c1_dtmf;
03950 void *pvt0, *pvt1;
03951
03952 int frame_put_in_jb = 0;
03953 int jb_in_use;
03954 int to;
03955
03956 cs[0] = c0;
03957 cs[1] = c1;
03958 pvt0 = c0->tech_pvt;
03959 pvt1 = c1->tech_pvt;
03960 o0nativeformats = c0->nativeformats;
03961 o1nativeformats = c1->nativeformats;
03962 watch_c0_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_0;
03963 watch_c1_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_1;
03964
03965
03966 jb_in_use = ast_jb_do_usecheck(c0, c1);
03967
03968 for (;;) {
03969 struct ast_channel *who, *other;
03970
03971 if ((c0->tech_pvt != pvt0) || (c1->tech_pvt != pvt1) ||
03972 (o0nativeformats != c0->nativeformats) ||
03973 (o1nativeformats != c1->nativeformats)) {
03974
03975 res = AST_BRIDGE_RETRY;
03976 break;
03977 }
03978 if (bridge_end.tv_sec) {
03979 to = ast_tvdiff_ms(bridge_end, ast_tvnow());
03980 if (to <= 0) {
03981 if (config->timelimit)
03982 res = AST_BRIDGE_RETRY;
03983 else
03984 res = AST_BRIDGE_COMPLETE;
03985 break;
03986 }
03987 } else
03988 to = -1;
03989
03990
03991 if (jb_in_use)
03992 to = ast_jb_get_when_to_wakeup(c0, c1, to);
03993 who = ast_waitfor_n(cs, 2, &to);
03994 if (!who) {
03995
03996 if (jb_in_use)
03997 ast_jb_get_and_deliver(c0, c1);
03998 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
03999 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
04000 c0->_softhangup = 0;
04001 if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
04002 c1->_softhangup = 0;
04003 c0->_bridge = c1;
04004 c1->_bridge = c0;
04005 }
04006 continue;
04007 }
04008 f = ast_read(who);
04009 if (!f) {
04010 *fo = NULL;
04011 *rc = who;
04012 if (option_debug)
04013 ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name);
04014 break;
04015 }
04016
04017 other = (who == c0) ? c1 : c0;
04018
04019 if (jb_in_use)
04020 frame_put_in_jb = !ast_jb_put(other, f);
04021
04022 if ((f->frametype == AST_FRAME_CONTROL) && !(config->flags & AST_BRIDGE_IGNORE_SIGS)) {
04023 int bridge_exit = 0;
04024
04025 switch (f->subclass) {
04026 case AST_CONTROL_HOLD:
04027 case AST_CONTROL_UNHOLD:
04028 case AST_CONTROL_VIDUPDATE:
04029 ast_indicate_data(other, f->subclass, f->data, f->datalen);
04030 break;
04031 default:
04032 *fo = f;
04033 *rc = who;
04034 bridge_exit = 1;
04035 if (option_debug)
04036 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
04037 break;
04038 }
04039 if (bridge_exit)
04040 break;
04041 }
04042 if ((f->frametype == AST_FRAME_VOICE) ||
04043 (f->frametype == AST_FRAME_DTMF_BEGIN) ||
04044 (f->frametype == AST_FRAME_DTMF) ||
04045 (f->frametype == AST_FRAME_VIDEO) ||
04046 (f->frametype == AST_FRAME_IMAGE) ||
04047 (f->frametype == AST_FRAME_HTML) ||
04048 (f->frametype == AST_FRAME_MODEM) ||
04049 (f->frametype == AST_FRAME_TEXT)) {
04050
04051 int monitored_source = (who == c0) ? watch_c0_dtmf : watch_c1_dtmf;
04052
04053 if (monitored_source &&
04054 (f->frametype == AST_FRAME_DTMF_END ||
04055 f->frametype == AST_FRAME_DTMF_BEGIN)) {
04056 *fo = f;
04057 *rc = who;
04058 if (option_debug)
04059 ast_log(LOG_DEBUG, "Got DTMF %s on channel (%s)\n",
04060 f->frametype == AST_FRAME_DTMF_END ? "end" : "begin",
04061 who->name);
04062 break;
04063 }
04064
04065 if (!frame_put_in_jb)
04066 ast_write(other, f);
04067
04068
04069 if (jb_in_use)
04070 ast_jb_get_and_deliver(c0, c1);
04071 }
04072
04073 ast_frfree(f);
04074
04075
04076 cs[2] = cs[0];
04077 cs[0] = cs[1];
04078 cs[1] = cs[2];
04079 }
04080 return res;
04081 }
04082
04083
04084 enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1,
04085 struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
04086 {
04087 struct ast_channel *who = NULL;
04088 enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
04089 int nativefailed=0;
04090 int firstpass;
04091 int o0nativeformats;
04092 int o1nativeformats;
04093 long time_left_ms=0;
04094 struct timeval nexteventts = { 0, };
04095 char caller_warning = 0;
04096 char callee_warning = 0;
04097
04098 if (c0->_bridge) {
04099 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
04100 c0->name, c0->_bridge->name);
04101 return -1;
04102 }
04103 if (c1->_bridge) {
04104 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
04105 c1->name, c1->_bridge->name);
04106 return -1;
04107 }
04108
04109
04110 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
04111 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1))
04112 return -1;
04113
04114 *fo = NULL;
04115 firstpass = config->firstpass;
04116 config->firstpass = 0;
04117
04118 if (ast_tvzero(config->start_time))
04119 config->start_time = ast_tvnow();
04120 time_left_ms = config->timelimit;
04121
04122 caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
04123 callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);
04124
04125 if (config->start_sound && firstpass) {
04126 if (caller_warning)
04127 bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
04128 if (callee_warning)
04129 bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
04130 }
04131
04132
04133 c0->_bridge = c1;
04134 c1->_bridge = c0;
04135
04136
04137 manager_event(EVENT_FLAG_CALL, "Link",
04138 "Channel1: %s\r\n"
04139 "Channel2: %s\r\n"
04140 "Uniqueid1: %s\r\n"
04141 "Uniqueid2: %s\r\n"
04142 "CallerID1: %s\r\n"
04143 "CallerID2: %s\r\n",
04144 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
04145
04146 o0nativeformats = c0->nativeformats;
04147 o1nativeformats = c1->nativeformats;
04148
04149 if (config->feature_timer) {
04150 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->feature_timer, 1000));
04151 } else if (config->timelimit) {
04152 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
04153 if (caller_warning || callee_warning)
04154 nexteventts = ast_tvsub(nexteventts, ast_samp2tv(config->play_warning, 1000));
04155 }
04156
04157 if (!c0->tech->send_digit_begin)
04158 ast_set_flag(c1, AST_FLAG_END_DTMF_ONLY);
04159 if (!c1->tech->send_digit_begin)
04160 ast_set_flag(c0, AST_FLAG_END_DTMF_ONLY);
04161
04162 for (;;) {
04163 struct timeval now = { 0, };
04164 int to;
04165
04166 to = -1;
04167
04168 if (!ast_tvzero(nexteventts)) {
04169 now = ast_tvnow();
04170 to = ast_tvdiff_ms(nexteventts, now);
04171 if (to <= 0) {
04172 if (!config->timelimit) {
04173 res = AST_BRIDGE_COMPLETE;
04174 break;
04175 }
04176 to = 0;
04177 }
04178 }
04179
04180 if (config->timelimit) {
04181 time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
04182 if (time_left_ms < to)
04183 to = time_left_ms;
04184
04185 if (time_left_ms <= 0) {
04186 if (caller_warning && config->end_sound)
04187 bridge_playfile(c0, c1, config->end_sound, 0);
04188 if (callee_warning && config->end_sound)
04189 bridge_playfile(c1, c0, config->end_sound, 0);
04190 *fo = NULL;
04191 if (who)
04192 *rc = who;
04193 res = 0;
04194 break;
04195 }
04196
04197 if (!to) {
04198 if (time_left_ms >= 5000 && config->warning_sound && config->play_warning) {
04199 int t = (time_left_ms + 500) / 1000;
04200 if (caller_warning)
04201 bridge_playfile(c0, c1, config->warning_sound, t);
04202 if (callee_warning)
04203 bridge_playfile(c1, c0, config->warning_sound, t);
04204 }
04205 if (config->warning_freq && (time_left_ms > (config->warning_freq + 5000)))
04206 nexteventts = ast_tvadd(nexteventts, ast_samp2tv(config->warning_freq, 1000));
04207 else
04208 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
04209 }
04210 }
04211
04212 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
04213 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
04214 c0->_softhangup = 0;
04215 if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
04216 c1->_softhangup = 0;
04217 c0->_bridge = c1;
04218 c1->_bridge = c0;
04219 if (option_debug)
04220 ast_log(LOG_DEBUG, "Unbridge signal received. Ending native bridge.\n");
04221 continue;
04222 }
04223
04224
04225 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
04226 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) {
04227 *fo = NULL;
04228 if (who)
04229 *rc = who;
04230 res = 0;
04231 if (option_debug)
04232 ast_log(LOG_DEBUG, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n",
04233 c0->name, c1->name,
04234 ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No",
04235 ast_check_hangup(c0) ? "Yes" : "No",
04236 ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No",
04237 ast_check_hangup(c1) ? "Yes" : "No");
04238 break;
04239 }
04240
04241
04242 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0, "BRIDGEPEER")))
04243 pbx_builtin_setvar_helper(c0, "BRIDGEPEER", c1->name);
04244 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1, "BRIDGEPEER")))
04245 pbx_builtin_setvar_helper(c1, "BRIDGEPEER", c0->name);
04246
04247 if (c0->tech->bridge &&
04248 (config->timelimit == 0) &&
04249 (c0->tech->bridge == c1->tech->bridge) &&
04250 !nativefailed && !c0->monitor && !c1->monitor &&
04251 !c0->spies && !c1->spies && !ast_test_flag(&(config->features_callee),AST_FEATURE_REDIRECT) &&
04252 !ast_test_flag(&(config->features_caller),AST_FEATURE_REDIRECT) ) {
04253
04254 ast_set_flag(c0, AST_FLAG_NBRIDGE);
04255 ast_set_flag(c1, AST_FLAG_NBRIDGE);
04256 if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, to)) == AST_BRIDGE_COMPLETE) {
04257
04258 manager_event(EVENT_FLAG_CALL, "Unlink",
04259 "Channel1: %s\r\n"
04260 "Channel2: %s\r\n"
04261 "Uniqueid1: %s\r\n"
04262 "Uniqueid2: %s\r\n"
04263 "CallerID1: %s\r\n"
04264 "CallerID2: %s\r\n",
04265 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
04266 if (option_debug)
04267 ast_log(LOG_DEBUG, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name);
04268
04269 ast_clear_flag(c0, AST_FLAG_NBRIDGE);
04270 ast_clear_flag(c1, AST_FLAG_NBRIDGE);
04271
04272 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
04273 continue;
04274
04275 c0->_bridge = NULL;
04276 c1->_bridge = NULL;
04277
04278 return res;
04279 } else {
04280 ast_clear_flag(c0, AST_FLAG_NBRIDGE);
04281 ast_clear_flag(c1, AST_FLAG_NBRIDGE);
04282 }
04283 switch (res) {
04284 case AST_BRIDGE_RETRY:
04285 continue;
04286 default:
04287 if (option_verbose > 2)
04288 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s ended\n",
04289 c0->name, c1->name);
04290
04291 case AST_BRIDGE_FAILED_NOWARN:
04292 nativefailed++;
04293 break;
04294 }
04295 }
04296
04297 if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) ||
04298 (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) &&
04299 !(c0->generator || c1->generator)) {
04300 if (ast_channel_make_compatible(c0, c1)) {
04301 ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name);
04302
04303 manager_event(EVENT_FLAG_CALL, "Unlink",
04304 "Channel1: %s\r\n"
04305 "Channel2: %s\r\n"
04306 "Uniqueid1: %s\r\n"
04307 "Uniqueid2: %s\r\n"
04308 "CallerID1: %s\r\n"
04309 "CallerID2: %s\r\n",
04310 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
04311 return AST_BRIDGE_FAILED;
04312 }
04313 o0nativeformats = c0->nativeformats;
04314 o1nativeformats = c1->nativeformats;
04315 }
04316 res = ast_generic_bridge(c0, c1, config, fo, rc, nexteventts);
04317 if (res != AST_BRIDGE_RETRY)
04318 break;
04319 }
04320
04321 ast_clear_flag(c0, AST_FLAG_END_DTMF_ONLY);
04322 ast_clear_flag(c1, AST_FLAG_END_DTMF_ONLY);
04323
04324 c0->_bridge = NULL;
04325 c1->_bridge = NULL;
04326
04327
04328 manager_event(EVENT_FLAG_CALL, "Unlink",
04329 "Channel1: %s\r\n"
04330 "Channel2: %s\r\n"
04331 "Uniqueid1: %s\r\n"
04332 "Uniqueid2: %s\r\n"
04333 "CallerID1: %s\r\n"
04334 "CallerID2: %s\r\n",
04335 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
04336 if (option_debug)
04337 ast_log(LOG_DEBUG, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name);
04338
04339 return res;
04340 }
04341
04342
04343 int ast_channel_setoption(struct ast_channel *chan, int option, void *data, int datalen, int block)
04344 {
04345 int res;
04346
04347 if (chan->tech->setoption) {
04348 res = chan->tech->setoption(chan, option, data, datalen);
04349 if (res < 0)
04350 return res;
04351 } else {
04352 errno = ENOSYS;
04353 return -1;
04354 }
04355 if (block) {
04356
04357
04358 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
04359 return -1;
04360 }
04361 return 0;
04362 }
04363
04364 struct tonepair_def {
04365 int freq1;
04366 int freq2;
04367 int duration;
04368 int vol;
04369 };
04370
04371 struct tonepair_state {
04372 int fac1;
04373 int fac2;
04374 int v1_1;
04375 int v2_1;
04376 int v3_1;
04377 int v1_2;
04378 int v2_2;
04379 int v3_2;
04380 int origwfmt;
04381 int pos;
04382 int duration;
04383 int modulate;
04384 struct ast_frame f;
04385 unsigned char offset[AST_FRIENDLY_OFFSET];
04386 short data[4000];
04387 };
04388
04389 static void tonepair_release(struct ast_channel *chan, void *params)
04390 {
04391 struct tonepair_state *ts = params;
04392
04393 if (chan)
04394 ast_set_write_format(chan, ts->origwfmt);
04395 free(ts);
04396 }
04397
04398 static void *tonepair_alloc(struct ast_channel *chan, void *params)
04399 {
04400 struct tonepair_state *ts;
04401 struct tonepair_def *td = params;
04402
04403 if (!(ts = ast_calloc(1, sizeof(*ts))))
04404 return NULL;
04405 ts->origwfmt = chan->writeformat;
04406 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
04407 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name);
04408 tonepair_release(NULL, ts);
04409 ts = NULL;
04410 } else {
04411 ts->fac1 = 2.0 * cos(2.0 * M_PI * (td->freq1 / 8000.0)) * 32768.0;
04412 ts->v1_1 = 0;
04413 ts->v2_1 = sin(-4.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
04414 ts->v3_1 = sin(-2.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
04415 ts->v2_1 = 0;
04416 ts->fac2 = 2.0 * cos(2.0 * M_PI * (td->freq2 / 8000.0)) * 32768.0;
04417 ts->v2_2 = sin(-4.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
04418 ts->v3_2 = sin(-2.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
04419 ts->duration = td->duration;
04420 ts->modulate = 0;
04421 }
04422
04423 ast_set_flag(chan, AST_FLAG_WRITE_INT);
04424 return ts;
04425 }
04426
04427 static int tonepair_generator(struct ast_channel *chan, void *data, int len, int samples)
04428 {
04429 struct tonepair_state *ts = data;
04430 int x;
04431
04432
04433
04434
04435 len = samples * 2;
04436
04437 if (len > sizeof(ts->data) / 2 - 1) {
04438 ast_log(LOG_WARNING, "Can't generate that much data!\n");
04439 return -1;
04440 }
04441 memset(&ts->f, 0, sizeof(ts->f));
04442 for (x=0;x<len/2;x++) {
04443 ts->v1_1 = ts->v2_1;
04444 ts->v2_1 = ts->v3_1;
04445 ts->v3_1 = (ts->fac1 * ts->v2_1 >> 15) - ts->v1_1;
04446
04447 ts->v1_2 = ts->v2_2;
04448 ts->v2_2 = ts->v3_2;
04449 ts->v3_2 = (ts->fac2 * ts->v2_2 >> 15) - ts->v1_2;
04450 if (ts->modulate) {
04451 int p;
04452 p = ts->v3_2 - 32768;
04453 if (p < 0) p = -p;
04454 p = ((p * 9) / 10) + 1;
04455 ts->data[x] = (ts->v3_1 * p) >> 15;
04456 } else
04457 ts->data[x] = ts->v3_1 + ts->v3_2;
04458 }
04459 ts->f.frametype = AST_FRAME_VOICE;
04460 ts->f.subclass = AST_FORMAT_SLINEAR;
04461 ts->f.datalen = len;
04462 ts->f.samples = samples;
04463 ts->f.offset = AST_FRIENDLY_OFFSET;
04464 ts->f.data = ts->data;
04465 ast_write(chan, &ts->f);
04466 ts->pos += x;
04467 if (ts->duration > 0) {
04468 if (ts->pos >= ts->duration * 8)
04469 return -1;
04470 }
04471 return 0;
04472 }
04473
04474 static struct ast_generator tonepair = {
04475 alloc: tonepair_alloc,
04476 release: tonepair_release,
04477 generate: tonepair_generator,
04478 };
04479
04480 int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
04481 {
04482 struct tonepair_def d = { 0, };
04483
04484 d.freq1 = freq1;
04485 d.freq2 = freq2;
04486 d.duration = duration;
04487 d.vol = (vol < 1) ? 8192 : vol;
04488 if (ast_activate_generator(chan, &tonepair, &d))
04489 return -1;
04490 return 0;
04491 }
04492
04493 void ast_tonepair_stop(struct ast_channel *chan)
04494 {
04495 ast_deactivate_generator(chan);
04496 }
04497
04498 int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
04499 {
04500 int res;
04501
04502 if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol)))
04503 return res;
04504
04505
04506 while (chan->generatordata && ast_waitfor(chan, 100) >= 0) {
04507 struct ast_frame *f = ast_read(chan);
04508 if (f)
04509 ast_frfree(f);
04510 else
04511 return -1;
04512 }
04513 return 0;
04514 }
04515
04516 ast_group_t ast_get_group(const char *s)
04517 {
04518 char *piece;
04519 char *c;
04520 int start=0, finish=0, x;
04521 ast_group_t group = 0;
04522
04523 c = ast_strdupa(s);
04524
04525 while ((piece = strsep(&c, ","))) {
04526 if (sscanf(piece, "%d-%d", &start, &finish) == 2) {
04527
04528 } else if (sscanf(piece, "%d", &start)) {
04529
04530 finish = start;
04531 } else {
04532 ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
04533 continue;
04534 }
04535 for (x = start; x <= finish; x++) {
04536 if ((x > 63) || (x < 0)) {
04537 ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
04538 } else
04539 group |= ((ast_group_t) 1 << x);
04540 }
04541 }
04542 return group;
04543 }
04544
04545 static int (*ast_moh_start_ptr)(struct ast_channel *, const char *, const char *) = NULL;
04546 static void (*ast_moh_stop_ptr)(struct ast_channel *) = NULL;
04547 static void (*ast_moh_cleanup_ptr)(struct ast_channel *) = NULL;
04548
04549 void ast_install_music_functions(int (*start_ptr)(struct ast_channel *, const char *, const char *),
04550 void (*stop_ptr)(struct ast_channel *),
04551 void (*cleanup_ptr)(struct ast_channel *))
04552 {
04553 ast_moh_start_ptr = start_ptr;
04554 ast_moh_stop_ptr = stop_ptr;
04555 ast_moh_cleanup_ptr = cleanup_ptr;
04556 }
04557
04558 void ast_uninstall_music_functions(void)
04559 {
04560 ast_moh_start_ptr = NULL;
04561 ast_moh_stop_ptr = NULL;
04562 ast_moh_cleanup_ptr = NULL;
04563 }
04564
04565
04566 int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
04567 {
04568 if (ast_moh_start_ptr)
04569 return ast_moh_start_ptr(chan, mclass, interpclass);
04570
04571 if (option_verbose > 2) {
04572 ast_verbose(VERBOSE_PREFIX_3 "Music class %s requested but no musiconhold loaded.\n",
04573 mclass ? mclass : (interpclass ? interpclass : "default"));
04574 }
04575
04576 return 0;
04577 }
04578
04579
04580 void ast_moh_stop(struct ast_channel *chan)
04581 {
04582 if (ast_moh_stop_ptr)
04583 ast_moh_stop_ptr(chan);
04584 }
04585
04586 void ast_moh_cleanup(struct ast_channel *chan)
04587 {
04588 if (ast_moh_cleanup_ptr)
04589 ast_moh_cleanup_ptr(chan);
04590 }
04591
04592 void ast_channels_init(void)
04593 {
04594 ast_cli_register_multiple(cli_channel, sizeof(cli_channel) / sizeof(struct ast_cli_entry));
04595 }
04596
04597
04598 char *ast_print_group(char *buf, int buflen, ast_group_t group)
04599 {
04600 unsigned int i;
04601 int first=1;
04602 char num[3];
04603
04604 buf[0] = '\0';
04605
04606 if (!group)
04607 return buf;
04608
04609 for (i = 0; i <= 63; i++) {
04610 if (group & ((ast_group_t) 1 << i)) {
04611 if (!first) {
04612 strncat(buf, ", ", buflen);
04613 } else {
04614 first=0;
04615 }
04616 snprintf(num, sizeof(num), "%u", i);
04617 strncat(buf, num, buflen);
04618 }
04619 }
04620 return buf;
04621 }
04622
04623 void ast_set_variables(struct ast_channel *chan, struct ast_variable *vars)
04624 {
04625 struct ast_variable *cur;
04626
04627 for (cur = vars; cur; cur = cur->next)
04628 pbx_builtin_setvar_helper(chan, cur->name, cur->value);
04629 }
04630
04631 static void copy_data_from_queue(struct ast_channel_spy_queue *queue, short *buf, unsigned int samples)
04632 {
04633 struct ast_frame *f;
04634 int tocopy;
04635 int bytestocopy;
04636
04637 while (samples) {
04638 if (!(f = AST_LIST_FIRST(&queue->list))) {
04639 ast_log(LOG_ERROR, "Ran out of frames before buffer filled!\n");
04640 break;
04641 }
04642
04643 tocopy = (f->samples > samples) ? samples : f->samples;
04644 bytestocopy = ast_codec_get_len(queue->format, tocopy);
04645 memcpy(buf, f->data, bytestocopy);
04646 samples -= tocopy;
04647 buf += tocopy;
04648 f->samples -= tocopy;
04649 f->data += bytestocopy;
04650 f->datalen -= bytestocopy;
04651 f->offset += bytestocopy;
04652 queue->samples -= tocopy;
04653
04654 if (!f->samples)
04655 ast_frfree(AST_LIST_REMOVE_HEAD(&queue->list, frame_list));
04656 }
04657 }
04658
04659 struct ast_frame *ast_channel_spy_read_frame(struct ast_channel_spy *spy, unsigned int samples)
04660 {
04661 struct ast_frame *result;
04662
04663 short read_buf[samples];
04664 short write_buf[samples];
04665 struct ast_frame *read_frame;
04666 struct ast_frame *write_frame;
04667 int need_dup;
04668 struct ast_frame stack_read_frame = { .frametype = AST_FRAME_VOICE,
04669 .subclass = spy->read_queue.format,
04670 .data = read_buf,
04671 .samples = samples,
04672 .datalen = ast_codec_get_len(spy->read_queue.format, samples),
04673 };
04674 struct ast_frame stack_write_frame = { .frametype = AST_FRAME_VOICE,
04675 .subclass = spy->write_queue.format,
04676 .data = write_buf,
04677 .samples = samples,
04678 .datalen = ast_codec_get_len(spy->write_queue.format, samples),
04679 };
04680
04681
04682 if (ast_test_flag(spy, CHANSPY_TRIGGER_FLUSH)) {
04683 if (spy->read_queue.samples > spy->write_queue.samples) {
04684 if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST)) {
04685 AST_LIST_TRAVERSE(&spy->read_queue.list, result, frame_list)
04686 ast_frame_adjust_volume(result, spy->read_vol_adjustment);
04687 }
04688 result = AST_LIST_FIRST(&spy->read_queue.list);
04689 AST_LIST_HEAD_SET_NOLOCK(&spy->read_queue.list, NULL);
04690 spy->read_queue.samples = 0;
04691 } else {
04692 if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST)) {
04693 AST_LIST_TRAVERSE(&spy->write_queue.list, result, frame_list)
04694 ast_frame_adjust_volume(result, spy->write_vol_adjustment);
04695 }
04696 result = AST_LIST_FIRST(&spy->write_queue.list);
04697 AST_LIST_HEAD_SET_NOLOCK(&spy->write_queue.list, NULL);
04698 spy->write_queue.samples = 0;
04699 }
04700 ast_clear_flag(spy, CHANSPY_TRIGGER_FLUSH);
04701 return result;
04702 }
04703
04704 if ((spy->read_queue.samples < samples) || (spy->write_queue.samples < samples))
04705 return NULL;
04706
04707
04708 if ((AST_LIST_FIRST(&spy->read_queue.list)->samples == samples) &&
04709 (AST_LIST_FIRST(&spy->write_queue.list)->samples == samples)) {
04710 read_frame = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list);
04711 write_frame = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list);
04712
04713 spy->read_queue.samples -= samples;
04714 spy->write_queue.samples -= samples;
04715
04716 need_dup = 0;
04717 } else {
04718 copy_data_from_queue(&spy->read_queue, read_buf, samples);
04719 copy_data_from_queue(&spy->write_queue, write_buf, samples);
04720
04721 read_frame = &stack_read_frame;
04722 write_frame = &stack_write_frame;
04723 need_dup = 1;
04724 }
04725
04726 if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST))
04727 ast_frame_adjust_volume(read_frame, spy->read_vol_adjustment);
04728
04729 if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST))
04730 ast_frame_adjust_volume(write_frame, spy->write_vol_adjustment);
04731
04732 if (ast_test_flag(spy, CHANSPY_MIXAUDIO)) {
04733 ast_frame_slinear_sum(read_frame, write_frame);
04734
04735 if (need_dup)
04736 result = ast_frdup(read_frame);
04737 else {
04738 result = read_frame;
04739 ast_frfree(write_frame);
04740 }
04741 } else {
04742 if (need_dup) {
04743 result = ast_frdup(read_frame);
04744 AST_LIST_NEXT(result, frame_list) = ast_frdup(write_frame);
04745 } else {
04746 result = read_frame;
04747 AST_LIST_NEXT(result, frame_list) = write_frame;
04748 }
04749 }
04750
04751 return result;
04752 }
04753
04754 static void *silence_generator_alloc(struct ast_channel *chan, void *data)
04755 {
04756
04757 return data;
04758 }
04759
04760 static void silence_generator_release(struct ast_channel *chan, void *data)
04761 {
04762
04763 }
04764
04765 static int silence_generator_generate(struct ast_channel *chan, void *data, int len, int samples)
04766 {
04767 short buf[samples];
04768 struct ast_frame frame = {
04769 .frametype = AST_FRAME_VOICE,
04770 .subclass = AST_FORMAT_SLINEAR,
04771 .data = buf,
04772 .samples = samples,
04773 .datalen = sizeof(buf),
04774 };
04775 memset(buf, 0, sizeof(buf));
04776 if (ast_write(chan, &frame))
04777 return -1;
04778 return 0;
04779 }
04780
04781 static struct ast_generator silence_generator = {
04782 .alloc = silence_generator_alloc,
04783 .release = silence_generator_release,
04784 .generate = silence_generator_generate,
04785 };
04786
04787 struct ast_silence_generator {
04788 int old_write_format;
04789 };
04790
04791 struct ast_silence_generator *ast_channel_start_silence_generator(struct ast_channel *chan)
04792 {
04793 struct ast_silence_generator *state;
04794
04795 if (!(state = ast_calloc(1, sizeof(*state)))) {
04796 return NULL;
04797 }
04798
04799 state->old_write_format = chan->writeformat;
04800
04801 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
04802 ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
04803 free(state);
04804 return NULL;
04805 }
04806
04807 ast_activate_generator(chan, &silence_generator, state);
04808
04809 if (option_debug)
04810 ast_log(LOG_DEBUG, "Started silence generator on '%s'\n", chan->name);
04811
04812 return state;
04813 }
04814
04815 void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
04816 {
04817 if (!state)
04818 return;
04819
04820 ast_deactivate_generator(chan);
04821
04822 if (option_debug)
04823 ast_log(LOG_DEBUG, "Stopped silence generator on '%s'\n", chan->name);
04824
04825 if (ast_set_write_format(chan, state->old_write_format) < 0)
04826 ast_log(LOG_ERROR, "Could not return write format to its original state\n");
04827
04828 free(state);
04829 }
04830
04831
04832
04833 const char *channelreloadreason2txt(enum channelreloadreason reason)
04834 {
04835 switch (reason) {
04836 case CHANNEL_MODULE_LOAD:
04837 return "LOAD (Channel module load)";
04838
04839 case CHANNEL_MODULE_RELOAD:
04840 return "RELOAD (Channel module reload)";
04841
04842 case CHANNEL_CLI_RELOAD:
04843 return "CLIRELOAD (Channel module reload by CLI command)";
04844
04845 default:
04846 return "MANAGERRELOAD (Channel module reload by manager)";
04847 }
04848 };
04849
04850 #ifdef DEBUG_CHANNEL_LOCKS
04851
04852
04853
04854
04855 int ast_channel_unlock(struct ast_channel *chan)
04856 {
04857 int res = 0;
04858 if (option_debug > 2)
04859 ast_log(LOG_DEBUG, "::::==== Unlocking AST channel %s\n", chan->name);
04860
04861 if (!chan) {
04862 if (option_debug)
04863 ast_log(LOG_DEBUG, "::::==== Unlocking non-existing channel \n");
04864 return 0;
04865 }
04866
04867 res = ast_mutex_unlock(&chan->lock);
04868
04869 if (option_debug > 2) {
04870 #ifdef DEBUG_THREADS
04871 int count = 0;
04872 if ((count = chan->lock.reentrancy))
04873 ast_log(LOG_DEBUG, ":::=== Still have %d locks (recursive)\n", count);
04874 #endif
04875 if (!res)
04876 if (option_debug)
04877 ast_log(LOG_DEBUG, "::::==== Channel %s was unlocked\n", chan->name);
04878 if (res == EINVAL) {
04879 if (option_debug)
04880 ast_log(LOG_DEBUG, "::::==== Channel %s had no lock by this thread. Failed unlocking\n", chan->name);
04881 }
04882 }
04883 if (res == EPERM) {
04884
04885 if (option_debug > 3)
04886 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked at all \n", chan->name);
04887 res = 0;
04888 }
04889 return res;
04890 }
04891
04892
04893
04894 int ast_channel_lock(struct ast_channel *chan)
04895 {
04896 int res;
04897
04898 if (option_debug > 3)
04899 ast_log(LOG_DEBUG, "====:::: Locking AST channel %s\n", chan->name);
04900
04901 res = ast_mutex_lock(&chan->lock);
04902
04903 if (option_debug > 3) {
04904 #ifdef DEBUG_THREADS
04905 int count = 0;
04906 if ((count = chan->lock.reentrancy))
04907 ast_log(LOG_DEBUG, ":::=== Now have %d locks (recursive)\n", count);
04908 #endif
04909 if (!res)
04910 ast_log(LOG_DEBUG, "::::==== Channel %s was locked\n", chan->name);
04911 if (res == EDEADLK) {
04912
04913 if (option_debug > 3)
04914 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked by us. Lock would cause deadlock.\n", chan->name);
04915 }
04916 if (res == EINVAL) {
04917 if (option_debug > 3)
04918 ast_log(LOG_DEBUG, "::::==== Channel %s lock failed. No mutex.\n", chan->name);
04919 }
04920 }
04921 return res;
04922 }
04923
04924
04925
04926 int ast_channel_trylock(struct ast_channel *chan)
04927 {
04928 int res;
04929
04930 if (option_debug > 2)
04931 ast_log(LOG_DEBUG, "====:::: Trying to lock AST channel %s\n", chan->name);
04932
04933 res = ast_mutex_trylock(&chan->lock);
04934
04935 if (option_debug > 2) {
04936 #ifdef DEBUG_THREADS
04937 int count = 0;
04938 if ((count = chan->lock.reentrancy))
04939 ast_log(LOG_DEBUG, ":::=== Now have %d locks (recursive)\n", count);
04940 #endif
04941 if (!res)
04942 ast_log(LOG_DEBUG, "::::==== Channel %s was locked\n", chan->name);
04943 if (res == EBUSY) {
04944
04945 if (option_debug > 2)
04946 ast_log(LOG_DEBUG, "::::==== Channel %s failed to lock. Not waiting around...\n", chan->name);
04947 }
04948 if (res == EDEADLK) {
04949
04950 if (option_debug > 2)
04951 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked. Lock would cause deadlock.\n", chan->name);
04952 }
04953 if (res == EINVAL && option_debug > 2)
04954 ast_log(LOG_DEBUG, "::::==== Channel %s lock failed. No mutex.\n", chan->name);
04955 }
04956 return res;
04957 }
04958
04959 #endif
04960
04961
04962
04963
04964
04965
04966
04967
04968
04969 int ast_say_number(struct ast_channel *chan, int num,
04970 const char *ints, const char *language, const char *options)
04971 {
04972 return ast_say_number_full(chan, num, ints, language, options, -1, -1);
04973 }
04974
04975 int ast_say_enumeration(struct ast_channel *chan, int num,
04976 const char *ints, const char *language, const char *options)
04977 {
04978 return ast_say_enumeration_full(chan, num, ints, language, options, -1, -1);
04979 }
04980
04981 int ast_say_digits(struct ast_channel *chan, int num,
04982 const char *ints, const char *lang)
04983 {
04984 return ast_say_digits_full(chan, num, ints, lang, -1, -1);
04985 }
04986
04987 int ast_say_digit_str(struct ast_channel *chan, const char *str,
04988 const char *ints, const char *lang)
04989 {
04990 return ast_say_digit_str_full(chan, str, ints, lang, -1, -1);
04991 }
04992
04993 int ast_say_character_str(struct ast_channel *chan, const char *str,
04994 const char *ints, const char *lang)
04995 {
04996 return ast_say_character_str_full(chan, str, ints, lang, -1, -1);
04997 }
04998
04999 int ast_say_phonetic_str(struct ast_channel *chan, const char *str,
05000 const char *ints, const char *lang)
05001 {
05002 return ast_say_phonetic_str_full(chan, str, ints, lang, -1, -1);
05003 }
05004
05005 int ast_say_digits_full(struct ast_channel *chan, int num,
05006 const char *ints, const char *lang, int audiofd, int ctrlfd)
05007 {
05008 char buf[256];
05009
05010 snprintf(buf, sizeof(buf), "%d", num);
05011 return ast_say_digit_str_full(chan, buf, ints, lang, audiofd, ctrlfd);
05012 }
05013
05014 int ast_channel_whisper_start(struct ast_channel *chan)
05015 {
05016 if (chan->whisper)
05017 return -1;
05018
05019 if (!(chan->whisper = ast_calloc(1, sizeof(*chan->whisper))))
05020 return -1;
05021
05022 ast_mutex_init(&chan->whisper->lock);
05023 ast_slinfactory_init(&chan->whisper->sf);
05024 ast_set_flag(chan, AST_FLAG_WHISPER);
05025
05026 return 0;
05027 }
05028
05029 int ast_channel_whisper_feed(struct ast_channel *chan, struct ast_frame *f)
05030 {
05031 if (!chan->whisper)
05032 return -1;
05033
05034 ast_mutex_lock(&chan->whisper->lock);
05035 ast_slinfactory_feed(&chan->whisper->sf, f);
05036 ast_mutex_unlock(&chan->whisper->lock);
05037
05038 return 0;
05039 }
05040
05041 void ast_channel_whisper_stop(struct ast_channel *chan)
05042 {
05043 if (!chan->whisper)
05044 return;
05045
05046 ast_clear_flag(chan, AST_FLAG_WHISPER);
05047 if (chan->whisper->path)
05048 ast_translator_free_path(chan->whisper->path);
05049 if (chan->whisper->original_format && chan->writeformat == AST_FORMAT_SLINEAR)
05050 ast_set_write_format(chan, chan->whisper->original_format);
05051 ast_slinfactory_destroy(&chan->whisper->sf);
05052 ast_mutex_destroy(&chan->whisper->lock);
05053 free(chan->whisper);
05054 chan->whisper = NULL;
05055 }