diff options
Diffstat (limited to 'main/channel.c')
-rw-r--r-- | main/channel.c | 182 |
1 files changed, 65 insertions, 117 deletions
diff --git a/main/channel.c b/main/channel.c index 387b98bea..9222a33c6 100644 --- a/main/channel.c +++ b/main/channel.c @@ -583,14 +583,14 @@ int ast_channel_trace_disable(struct ast_channel *chan) /*! \brief Checks to see if a channel is needing hang up */ int ast_check_hangup(struct ast_channel *chan) { - if (chan->_softhangup) /* yes if soft hangup flag set */ + if (ast_channel_softhangup_internal_flag(chan)) /* yes if soft hangup flag set */ return 1; if (ast_tvzero(*ast_channel_whentohangup(chan))) /* no if no hangup scheduled */ return 0; if (ast_tvdiff_ms(*ast_channel_whentohangup(chan), ast_tvnow()) > 0) /* no if hangup time has not come yet. */ return 0; ast_debug(4, "Hangup time has come: %" PRIi64 "\n", ast_tvdiff_ms(*ast_channel_whentohangup(chan), ast_tvnow())); - chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; /* record event */ + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_TIMEOUT); /* record event */ return 1; } @@ -921,8 +921,6 @@ __ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char const char *function, const char *name_fmt, va_list ap) { struct ast_channel *tmp; - int x; - int flags; struct varshead *headp; char *tech = "", *tech2 = NULL; struct ast_format_cap *nativeformats; @@ -960,12 +958,9 @@ __ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char * the destructor can know not to close them. */ ast_channel_timingfd_set(tmp, -1); - for (x = 0; x < ARRAY_LEN(tmp->alertpipe); ++x) { - tmp->alertpipe[x] = -1; - } - for (x = 0; x < ARRAY_LEN(tmp->fds); ++x) { - tmp->fds[x] = -1; - } + ast_channel_internal_alertpipe_clear(tmp); + ast_channel_internal_fd_clear_all(tmp); + #ifdef HAVE_EPOLL ast_channel_epfd(tmp) = epoll_create(25); #endif @@ -1004,22 +999,8 @@ __ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char ast_channel_timingfd_set(tmp, ast_timer_fd(ast_channel_timer(tmp))); } - if (needqueue) { - if (pipe(tmp->alertpipe)) { - ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe! Try increasing max file descriptors with ulimit -n\n"); - return ast_channel_unref(tmp); - } else { - flags = fcntl(tmp->alertpipe[0], F_GETFL); - if (fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) { - ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); - return ast_channel_unref(tmp); - } - flags = fcntl(tmp->alertpipe[1], F_GETFL); - if (fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK) < 0) { - ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); - return ast_channel_unref(tmp); - } - } + if (needqueue && ast_channel_internal_alertpipe_init(tmp)) { + return ast_channel_unref(tmp); } /* @@ -1034,7 +1015,7 @@ __ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char } /* Always watch the alertpipe */ - ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]); + ast_channel_set_fd(tmp, AST_ALERT_FD, ast_channel_internal_alert_readfd(tmp)); /* And timing pipe */ ast_channel_set_fd(tmp, AST_TIMING_FD, ast_channel_timingfd(tmp)); @@ -1308,11 +1289,8 @@ static int __ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin, in AST_LIST_APPEND_LIST(ast_channel_readq(chan), &frames, frame_list); } - if (chan->alertpipe[1] > -1) { - int blah[new_frames]; - - memset(blah, 1, sizeof(blah)); - if (write(chan->alertpipe[1], &blah, sizeof(blah)) != (sizeof(blah))) { + if (ast_channel_alert_writable(chan)) { + if (ast_channel_alert_write(chan)) { ast_log(LOG_WARNING, "Unable to write to alert pipe on %s (qlen = %d): %s!\n", ast_channel_name(chan), queued_frames, strerror(errno)); } @@ -1343,7 +1321,7 @@ int ast_queue_hangup(struct ast_channel *chan) struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP }; /* Yeah, let's not change a lock-critical value without locking */ if (!ast_channel_trylock(chan)) { - chan->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); manager_event(EVENT_FLAG_CALL, "HangupRequest", "Channel: %s\r\n" "Uniqueid: %s\r\n", @@ -1364,7 +1342,7 @@ int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause) /* Yeah, let's not change a lock-critical value without locking */ if (!ast_channel_trylock(chan)) { - chan->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); if (cause < 0) f.data.uint32 = ast_channel_hangupcause(chan); @@ -2185,7 +2163,6 @@ void ast_party_redirecting_free(struct ast_party_redirecting *doomed) static void ast_channel_destructor(void *obj) { struct ast_channel *chan = obj; - int fd; #ifdef HAVE_EPOLL int i; #endif @@ -2256,17 +2233,15 @@ static void ast_channel_destructor(void *obj) ast_party_redirecting_free(ast_channel_redirecting(chan)); /* Close pipes if appropriate */ - if ((fd = chan->alertpipe[0]) > -1) - close(fd); - if ((fd = chan->alertpipe[1]) > -1) - close(fd); + ast_channel_internal_alertpipe_close(chan); if (ast_channel_timer(chan)) { ast_timer_close(ast_channel_timer(chan)); } #ifdef HAVE_EPOLL for (i = 0; i < AST_MAX_FDS; i++) { - if (chan->epfd_data[i]) - free(chan->epfd_data[i]); + if (ast_channel_internal_epfd_data(chan, i)) { + ast_free(ast_channel_internal_epfd_data(chan, i)); + } } close(ast_channel_epfd(chan)); #endif @@ -2410,9 +2385,9 @@ void ast_channel_set_fd(struct ast_channel *chan, int which, int fd) struct epoll_event ev; struct ast_epoll_data *aed = NULL; - if (chan->fds[which] > -1) { - epoll_ctl(ast_channel_epfd(chan), EPOLL_CTL_DEL, chan->fds[which], &ev); - aed = chan->epfd_data[which]; + if (ast_channel_fd_isset(chan, which)) { + epoll_ctl(ast_channel_epfd(chan), EPOLL_CTL_DEL, ast_channel_fd(chan, which), &ev); + aed = ast_channel_internal_epfd_data(chan, which); } /* If this new fd is valid, add it to the epoll */ @@ -2420,7 +2395,7 @@ void ast_channel_set_fd(struct ast_channel *chan, int which, int fd) if (!aed && (!(aed = ast_calloc(1, sizeof(*aed))))) return; - chan->epfd_data[which] = aed; + ast_channel_internal_epfd_data_set(chan, which, aed); aed->chan = chan; aed->which = which; @@ -2429,11 +2404,11 @@ void ast_channel_set_fd(struct ast_channel *chan, int which, int fd) epoll_ctl(ast_channel_epfd(chan), EPOLL_CTL_ADD, fd, &ev); } else if (aed) { /* We don't have to keep around this epoll data structure now */ - free(aed); - chan->epfd_data[which] = NULL; + ast_free(aed); + ast_channel_epfd_data_set(chan, which, NULL); } #endif - chan->fds[which] = fd; + ast_channel_internal_fd_set(chan, which, fd); return; } @@ -2449,11 +2424,12 @@ void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1) /* Iterate through the file descriptors on chan1, adding them to chan0 */ for (i = 0; i < AST_MAX_FDS; i++) { - if (chan1->fds[i] == -1) + if (!ast_channel_fd_isset(chan1, i)) { continue; + } ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP; - ev.data.ptr = chan1->epfd_data[i]; - epoll_ctl(ast_channel_epfd(chan0), EPOLL_CTL_ADD, chan1->fds[i], &ev); + ev.data.ptr = ast_channel_internal_epfd_data(chan1, i); + epoll_ctl(ast_channel_epfd(chan0), EPOLL_CTL_ADD, ast_channel_fd(chan1, i), &ev); } #endif @@ -2471,9 +2447,10 @@ void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1) return; for (i = 0; i < AST_MAX_FDS; i++) { - if (chan1->fds[i] == -1) + if (!ast_channel_fd_isset(chan1, i)) { continue; - epoll_ctl(ast_channel_epfd(chan0), EPOLL_CTL_DEL, chan1->fds[i], &ev); + } + epoll_ctl(ast_channel_epfd(chan0), EPOLL_CTL_DEL, ast_channel_fd(chan1, i), &ev); } #endif @@ -2484,9 +2461,9 @@ void ast_channel_clear_softhangup(struct ast_channel *chan, int flag) { ast_channel_lock(chan); - chan->_softhangup &= ~flag; + ast_channel_softhangup_internal_flag_clear(chan, flag); - if (!chan->_softhangup) { + if (!ast_channel_softhangup_internal_flag(chan)) { struct ast_frame *fr; /* If we have completely cleared the softhangup flag, @@ -2510,7 +2487,7 @@ int ast_softhangup_nolock(struct ast_channel *chan, int cause) { ast_debug(1, "Soft-Hanging up channel '%s'\n", ast_channel_name(chan)); /* Inform channel driver that we need to be hung up, if it cares */ - chan->_softhangup |= cause; + ast_channel_softhangup_internal_flag_add(chan, cause); ast_queue_frame(chan, &ast_null_frame); /* Interrupt any poll call or such */ if (ast_test_flag(chan, AST_FLAG_BLOCKING)) @@ -3012,7 +2989,7 @@ struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, diff = ast_tvsub(*ast_channel_whentohangup(c[x]), now); if (diff.tv_sec < 0 || ast_tvzero(diff)) { /* Should already be hungup */ - c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(c[x], AST_SOFTHANGUP_TIMEOUT); ast_channel_unlock(c[x]); return c[x]; } @@ -3043,7 +3020,7 @@ struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, for (y = 0; y < AST_MAX_FDS; y++) { fdmap[max].fdno = y; /* fd y is linked to this pfds */ fdmap[max].chan = x; /* channel x is linked to this pfds */ - max += ast_add_fd(&pfds[max], c[x]->fds[y]); + max += ast_add_fd(&pfds[max], ast_channel_fd(c[x], y)); } CHECK_BLOCKING(c[x]); } @@ -3079,7 +3056,7 @@ struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, now = ast_tvnow(); for (x = 0; x < n; x++) { if (!ast_tvzero(*ast_channel_whentohangup(c[x])) && ast_tvcmp(*ast_channel_whentohangup(c[x]), now) <= 0) { - c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(c[x], AST_SOFTHANGUP_TIMEOUT); if (winner == NULL) winner = c[x]; } @@ -3144,7 +3121,7 @@ static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, if (!ast_tvzero(*ast_channel_whentohangup(chan))) { if ((diff = ast_tvdiff_ms(*ast_channel_whentohangup(chan), ast_tvnow())) < 0) { /* They should already be hungup! */ - chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_TIMEOUT); ast_channel_unlock(chan); return NULL; } @@ -3177,7 +3154,7 @@ static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, /* If this channel has a timeout see if it expired */ if (!ast_tvzero(*ast_channel_whentohangup(chan))) { if (ast_tvdiff_ms(ast_tvnow(), *ast_channel_whentohangup(chan)) >= 0) { - chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_TIMEOUT); winner = chan; } } @@ -3226,7 +3203,7 @@ static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, i if (whentohangup == 0) now = ast_tvnow(); if ((diff = ast_tvdiff_ms(*ast_channel_whentohangup(c[i]), now)) < 0) { - c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(c[i], AST_SOFTHANGUP_TIMEOUT); ast_channel_unlock(c[i]); return c[i]; } @@ -3262,7 +3239,7 @@ static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, i now = ast_tvnow(); for (i = 0; i < n; i++) { if (!ast_tvzero(*ast_channel_whentohangup(c[i])) && ast_tvdiff_ms(now, *ast_channel_whentohangup(c[i])) >= 0) { - c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; + ast_channel_softhangup_internal_flag_add(c[i], AST_SOFTHANGUP_TIMEOUT); if (!winner) winner = c[i]; } @@ -3576,7 +3553,6 @@ static inline int calc_monitor_jump(int samples, int sample_rate, int seek_rate) static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) { struct ast_frame *f = NULL; /* the return value */ - int blah; int prestate; int cause = 0; @@ -3609,7 +3585,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) * ast_queue_control() will be called repeatedly, but will only * queue the first end-of-Q frame. */ - if (chan->_softhangup) { + if (ast_channel_softhangup_internal_flag(chan)) { ast_queue_control(chan, AST_CONTROL_END_OF_Q); } else { goto done; @@ -3640,22 +3616,9 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) /* Read and ignore anything on the alertpipe, but read only one sizeof(blah) per frame that we send from it */ - if (chan->alertpipe[0] > -1) { - int flags = fcntl(chan->alertpipe[0], F_GETFL); - /* For some odd reason, the alertpipe occasionally loses nonblocking status, - * which immediately causes a deadlock scenario. Detect and prevent this. */ - if ((flags & O_NONBLOCK) == 0) { - ast_log(LOG_ERROR, "Alertpipe on channel %s lost O_NONBLOCK?!!\n", ast_channel_name(chan)); - if (fcntl(chan->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) { - ast_log(LOG_WARNING, "Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); - f = &ast_null_frame; - goto done; - } - } - if (read(chan->alertpipe[0], &blah, sizeof(blah)) < 0) { - if (errno != EINTR && errno != EAGAIN) - ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno)); - } + if (ast_channel_internal_alert_read(chan) == AST_ALERT_READ_FATAL) { + f = &ast_null_frame; + goto done; } if (ast_channel_timingfd(chan) > -1 && ast_channel_fdno(chan) == AST_TIMING_FD) { @@ -3693,7 +3656,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) break; } - } else if (chan->fds[AST_GENERATOR_FD] > -1 && ast_channel_fdno(chan) == AST_GENERATOR_FD) { + } else if (ast_channel_fd_isset(chan, AST_GENERATOR_FD) && ast_channel_fdno(chan) == AST_GENERATOR_FD) { /* if the AST_GENERATOR_FD is set, call the generator with args * set to -1 so it can do whatever it needs to. */ @@ -3704,7 +3667,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) f = &ast_null_frame; ast_channel_fdno_set(chan, -1); goto done; - } else if (chan->fds[AST_JITTERBUFFER_FD] > -1 && ast_channel_fdno(chan) == AST_JITTERBUFFER_FD) { + } else if (ast_channel_fd_isset(chan, AST_JITTERBUFFER_FD) && ast_channel_fdno(chan) == AST_JITTERBUFFER_FD) { ast_clear_flag(chan, AST_FLAG_EXCEPTION); } @@ -3729,14 +3692,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) if (!f) { /* There were no acceptable frames on the readq. */ f = &ast_null_frame; - if (chan->alertpipe[0] > -1) { - int poke = 0; - /* Restore the state of the alertpipe since we aren't ready for any - * of the frames in the readq. */ - if (write(chan->alertpipe[1], &poke, sizeof(poke)) != sizeof(poke)) { - ast_log(LOG_ERROR, "Failed to write to alertpipe: %s\n", strerror(errno)); - } - } + ast_channel_alert_write(chan); } /* Interpret hangup and end-of-Q frames to return NULL */ @@ -3744,7 +3700,7 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) if (f->frametype == AST_FRAME_CONTROL) { switch (f->subclass.integer) { case AST_CONTROL_HANGUP: - chan->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); cause = f->data.uint32; /* Fall through */ case AST_CONTROL_END_OF_Q: @@ -4084,8 +4040,8 @@ static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio) } } else { /* Make sure we always return NULL in the future */ - if (!chan->_softhangup) { - chan->_softhangup |= AST_SOFTHANGUP_DEV; + if (!ast_channel_softhangup_internal_flag(chan)) { + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); } if (cause) ast_channel_hangupcause_set(chan, cause); @@ -4908,7 +4864,7 @@ int ast_write(struct ast_channel *chan, struct ast_frame *fr) AST_LIST_NEXT(cur, frame_list) = NULL; if (!skip) { if ((res = ast_channel_tech(chan)->write(chan, cur)) < 0) { - chan->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); skip = 1; } else if (next) { /* don't do this for the last frame in the list, @@ -4946,7 +4902,7 @@ int ast_write(struct ast_channel *chan, struct ast_frame *fr) /* Consider a write failure to force a soft hangup */ if (res < 0) { - chan->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV); } else { ast_channel_fout_set(chan, FRAMECOUNT_INC(ast_channel_fout(chan))); } @@ -6442,7 +6398,7 @@ static void masquerade_colp_transfer(struct ast_channel *transferee, struct xfer */ int ast_do_masquerade(struct ast_channel *original) { - int x, i; + int x; int res=0; int origstate; int visible_indication; @@ -6603,11 +6559,7 @@ int ast_do_masquerade(struct ast_channel *original) ast_channel_tech_pvt_set(clonechan, t_pvt); /* Swap the alertpipes */ - for (i = 0; i < 2; i++) { - x = original->alertpipe[i]; - original->alertpipe[i] = clonechan->alertpipe[i]; - clonechan->alertpipe[i] = x; - } + ast_channel_internal_alertpipe_swap(original, clonechan); /* * Swap the readq's. The end result should be this: @@ -6629,12 +6581,8 @@ int ast_do_masquerade(struct ast_channel *original) while ((current = AST_LIST_REMOVE_HEAD(&tmp_readq, frame_list))) { AST_LIST_INSERT_TAIL(ast_channel_readq(original), current, frame_list); - if (original->alertpipe[1] > -1) { - int poke = 0; - - if (write(original->alertpipe[1], &poke, sizeof(poke)) < 0) { - ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno)); - } + if (ast_channel_alert_write(original)) { + ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno)); } } } @@ -6648,7 +6596,7 @@ int ast_do_masquerade(struct ast_channel *original) ast_format_copy(ast_channel_rawwriteformat(original), ast_channel_rawwriteformat(clonechan)); ast_format_copy(ast_channel_rawwriteformat(clonechan), &tmp_format); - clonechan->_softhangup = AST_SOFTHANGUP_DEV; + ast_channel_softhangup_internal_flag_set(clonechan, AST_SOFTHANGUP_DEV); /* And of course, so does our current state. Note we need not call ast_setstate since the event manager doesn't really consider @@ -6689,7 +6637,7 @@ int ast_do_masquerade(struct ast_channel *original) /* Copy the FD's other than the generator fd */ for (x = 0; x < AST_MAX_FDS; x++) { if (x != AST_GENERATOR_FD) - ast_channel_set_fd(original, x, clonechan->fds[x]); + ast_channel_set_fd(original, x, ast_channel_fd(clonechan, x)); } ast_app_group_update(clonechan, original); @@ -7113,11 +7061,11 @@ static enum ast_bridge_result ast_generic_bridge(struct ast_channel *c0, struct /* No frame received within the specified timeout - check if we have to deliver now */ if (jb_in_use) ast_jb_get_and_deliver(c0, c1); - if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ - if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { + if ((ast_channel_softhangup_internal_flag(c0) | ast_channel_softhangup_internal_flag(c1)) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ + if (ast_channel_softhangup_internal_flag(c0) & AST_SOFTHANGUP_UNBRIDGE) { ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE); } - if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { + if (ast_channel_softhangup_internal_flag(c1) & AST_SOFTHANGUP_UNBRIDGE) { ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE); } c0->_bridge = c1; @@ -7469,11 +7417,11 @@ enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_cha ast_clear_flag(config, AST_FEATURE_WARNING_ACTIVE); } - if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ - if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { + if ((ast_channel_softhangup_internal_flag(c0) | ast_channel_softhangup_internal_flag(c1)) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ + if (ast_channel_softhangup_internal_flag(c0) & AST_SOFTHANGUP_UNBRIDGE) { ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE); } - if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { + if (ast_channel_softhangup_internal_flag(c1) & AST_SOFTHANGUP_UNBRIDGE) { ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE); } c0->_bridge = c1; @@ -7519,7 +7467,7 @@ enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_cha ast_clear_flag(c0, AST_FLAG_NBRIDGE); ast_clear_flag(c1, AST_FLAG_NBRIDGE); - if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ + if ((ast_channel_softhangup_internal_flag(c0) | ast_channel_softhangup_internal_flag(c1)) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ continue; } |