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