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