mirror of
https://github.com/asterisk/asterisk.git
synced 2025-10-31 10:47:18 +00:00
Convert sig_analog to use a global callback table.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@370926 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Richard Mudgett
@@ -161,56 +161,56 @@ const char *analog_cidtype_to_str(unsigned int cid_type)
|
||||
|
||||
static int analog_start_cid_detect(struct analog_pvt *p, int cid_signalling)
|
||||
{
|
||||
if (p->calls->start_cid_detect) {
|
||||
return p->calls->start_cid_detect(p->chan_pvt, cid_signalling);
|
||||
if (analog_callbacks.start_cid_detect) {
|
||||
return analog_callbacks.start_cid_detect(p->chan_pvt, cid_signalling);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_stop_cid_detect(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->stop_cid_detect) {
|
||||
return p->calls->stop_cid_detect(p->chan_pvt);
|
||||
if (analog_callbacks.stop_cid_detect) {
|
||||
return analog_callbacks.stop_cid_detect(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_get_callerid(struct analog_pvt *p, char *name, char *number, enum analog_event *ev, size_t timeout)
|
||||
{
|
||||
if (p->calls->get_callerid) {
|
||||
return p->calls->get_callerid(p->chan_pvt, name, number, ev, timeout);
|
||||
if (analog_callbacks.get_callerid) {
|
||||
return analog_callbacks.get_callerid(p->chan_pvt, name, number, ev, timeout);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static const char *analog_get_orig_dialstring(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->get_orig_dialstring) {
|
||||
return p->calls->get_orig_dialstring(p->chan_pvt);
|
||||
if (analog_callbacks.get_orig_dialstring) {
|
||||
return analog_callbacks.get_orig_dialstring(p->chan_pvt);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
static int analog_get_event(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->get_event) {
|
||||
return p->calls->get_event(p->chan_pvt);
|
||||
if (analog_callbacks.get_event) {
|
||||
return analog_callbacks.get_event(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_wait_event(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->wait_event) {
|
||||
return p->calls->wait_event(p->chan_pvt);
|
||||
if (analog_callbacks.wait_event) {
|
||||
return analog_callbacks.wait_event(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_have_progressdetect(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->have_progressdetect) {
|
||||
return p->calls->have_progressdetect(p->chan_pvt);
|
||||
if (analog_callbacks.have_progressdetect) {
|
||||
return analog_callbacks.have_progressdetect(p->chan_pvt);
|
||||
}
|
||||
/* Don't have progress detection. */
|
||||
return 0;
|
||||
@@ -345,16 +345,16 @@ static void analog_swap_subs(struct analog_pvt *p, enum analog_sub a, enum analo
|
||||
p->subs[a].inthreeway = p->subs[b].inthreeway;
|
||||
p->subs[b].inthreeway = tinthreeway;
|
||||
|
||||
if (p->calls->swap_subs) {
|
||||
p->calls->swap_subs(p->chan_pvt, a, p->subs[a].owner, b, p->subs[b].owner);
|
||||
if (analog_callbacks.swap_subs) {
|
||||
analog_callbacks.swap_subs(p->chan_pvt, a, p->subs[a].owner, b, p->subs[b].owner);
|
||||
}
|
||||
}
|
||||
|
||||
static int analog_alloc_sub(struct analog_pvt *p, enum analog_sub x)
|
||||
{
|
||||
if (p->calls->allocate_sub) {
|
||||
if (analog_callbacks.allocate_sub) {
|
||||
int res;
|
||||
res = p->calls->allocate_sub(p->chan_pvt, x);
|
||||
res = analog_callbacks.allocate_sub(p->chan_pvt, x);
|
||||
if (!res) {
|
||||
p->subs[x].allocd = 1;
|
||||
}
|
||||
@@ -367,8 +367,8 @@ static int analog_unalloc_sub(struct analog_pvt *p, enum analog_sub x)
|
||||
{
|
||||
p->subs[x].allocd = 0;
|
||||
p->subs[x].owner = NULL;
|
||||
if (p->calls->unallocate_sub) {
|
||||
return p->calls->unallocate_sub(p->chan_pvt, x);
|
||||
if (analog_callbacks.unallocate_sub) {
|
||||
return analog_callbacks.unallocate_sub(p->chan_pvt, x);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -383,8 +383,8 @@ static int analog_send_callerid(struct analog_pvt *p, int cwcid, struct ast_part
|
||||
p->callwaitcas = 0;
|
||||
}
|
||||
|
||||
if (p->calls->send_callerid) {
|
||||
return p->calls->send_callerid(p->chan_pvt, cwcid, caller);
|
||||
if (analog_callbacks.send_callerid) {
|
||||
return analog_callbacks.send_callerid(p->chan_pvt, cwcid, caller);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -412,8 +412,8 @@ static int _analog_get_index(struct ast_channel *ast, struct analog_pvt *p, int
|
||||
|
||||
static int analog_dsp_reset_and_flush_digits(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->dsp_reset_and_flush_digits) {
|
||||
return p->calls->dsp_reset_and_flush_digits(p->chan_pvt);
|
||||
if (analog_callbacks.dsp_reset_and_flush_digits) {
|
||||
return analog_callbacks.dsp_reset_and_flush_digits(p->chan_pvt);
|
||||
}
|
||||
|
||||
/* Return 0 since I think this is unnecessary to do in most cases it is used. Mostly only for ast_dsp */
|
||||
@@ -422,8 +422,8 @@ static int analog_dsp_reset_and_flush_digits(struct analog_pvt *p)
|
||||
|
||||
static int analog_play_tone(struct analog_pvt *p, enum analog_sub sub, enum analog_tone tone)
|
||||
{
|
||||
if (p->calls->play_tone) {
|
||||
return p->calls->play_tone(p->chan_pvt, sub, tone);
|
||||
if (analog_callbacks.play_tone) {
|
||||
return analog_callbacks.play_tone(p->chan_pvt, sub, tone);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -431,8 +431,8 @@ static int analog_play_tone(struct analog_pvt *p, enum analog_sub sub, enum anal
|
||||
static void analog_set_new_owner(struct analog_pvt *p, struct ast_channel *new_owner)
|
||||
{
|
||||
p->owner = new_owner;
|
||||
if (p->calls->set_new_owner) {
|
||||
p->calls->set_new_owner(p->chan_pvt, new_owner);
|
||||
if (analog_callbacks.set_new_owner) {
|
||||
analog_callbacks.set_new_owner(p->chan_pvt, new_owner);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -440,11 +440,11 @@ static struct ast_channel * analog_new_ast_channel(struct analog_pvt *p, int sta
|
||||
{
|
||||
struct ast_channel *c;
|
||||
|
||||
if (!p->calls->new_ast_channel) {
|
||||
if (!analog_callbacks.new_ast_channel) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
c = p->calls->new_ast_channel(p->chan_pvt, state, startpbx, sub, requestor);
|
||||
c = analog_callbacks.new_ast_channel(p->chan_pvt, state, startpbx, sub, requestor);
|
||||
if (c) {
|
||||
ast_channel_call_forward_set(c, p->call_forward);
|
||||
}
|
||||
@@ -457,64 +457,64 @@ static struct ast_channel * analog_new_ast_channel(struct analog_pvt *p, int sta
|
||||
|
||||
static int analog_set_echocanceller(struct analog_pvt *p, int enable)
|
||||
{
|
||||
if (p->calls->set_echocanceller) {
|
||||
return p->calls->set_echocanceller(p->chan_pvt, enable);
|
||||
if (analog_callbacks.set_echocanceller) {
|
||||
return analog_callbacks.set_echocanceller(p->chan_pvt, enable);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_train_echocanceller(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->train_echocanceller) {
|
||||
return p->calls->train_echocanceller(p->chan_pvt);
|
||||
if (analog_callbacks.train_echocanceller) {
|
||||
return analog_callbacks.train_echocanceller(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_is_off_hook(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->is_off_hook) {
|
||||
return p->calls->is_off_hook(p->chan_pvt);
|
||||
if (analog_callbacks.is_off_hook) {
|
||||
return analog_callbacks.is_off_hook(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_ring(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->ring) {
|
||||
return p->calls->ring(p->chan_pvt);
|
||||
if (analog_callbacks.ring) {
|
||||
return analog_callbacks.ring(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_flash(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->flash) {
|
||||
return p->calls->flash(p->chan_pvt);
|
||||
if (analog_callbacks.flash) {
|
||||
return analog_callbacks.flash(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_start(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->start) {
|
||||
return p->calls->start(p->chan_pvt);
|
||||
if (analog_callbacks.start) {
|
||||
return analog_callbacks.start(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_dial_digits(struct analog_pvt *p, enum analog_sub sub, struct analog_dialoperation *dop)
|
||||
{
|
||||
if (p->calls->dial_digits) {
|
||||
return p->calls->dial_digits(p->chan_pvt, sub, dop);
|
||||
if (analog_callbacks.dial_digits) {
|
||||
return analog_callbacks.dial_digits(p->chan_pvt, sub, dop);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_on_hook(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->on_hook) {
|
||||
return p->calls->on_hook(p->chan_pvt);
|
||||
if (analog_callbacks.on_hook) {
|
||||
return analog_callbacks.on_hook(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -522,44 +522,44 @@ static int analog_on_hook(struct analog_pvt *p)
|
||||
static void analog_set_outgoing(struct analog_pvt *p, int is_outgoing)
|
||||
{
|
||||
p->outgoing = is_outgoing;
|
||||
if (p->calls->set_outgoing) {
|
||||
p->calls->set_outgoing(p->chan_pvt, is_outgoing);
|
||||
if (analog_callbacks.set_outgoing) {
|
||||
analog_callbacks.set_outgoing(p->chan_pvt, is_outgoing);
|
||||
}
|
||||
}
|
||||
|
||||
static int analog_check_for_conference(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->check_for_conference) {
|
||||
return p->calls->check_for_conference(p->chan_pvt);
|
||||
if (analog_callbacks.check_for_conference) {
|
||||
return analog_callbacks.check_for_conference(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void analog_all_subchannels_hungup(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->all_subchannels_hungup) {
|
||||
p->calls->all_subchannels_hungup(p->chan_pvt);
|
||||
if (analog_callbacks.all_subchannels_hungup) {
|
||||
analog_callbacks.all_subchannels_hungup(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_unlock_private(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->unlock_private) {
|
||||
p->calls->unlock_private(p->chan_pvt);
|
||||
if (analog_callbacks.unlock_private) {
|
||||
analog_callbacks.unlock_private(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_lock_private(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->lock_private) {
|
||||
p->calls->lock_private(p->chan_pvt);
|
||||
if (analog_callbacks.lock_private) {
|
||||
analog_callbacks.lock_private(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_deadlock_avoidance_private(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->deadlock_avoidance_private) {
|
||||
p->calls->deadlock_avoidance_private(p->chan_pvt);
|
||||
if (analog_callbacks.deadlock_avoidance_private) {
|
||||
analog_callbacks.deadlock_avoidance_private(p->chan_pvt);
|
||||
} else {
|
||||
/* Fallback to manual avoidance if callback not present. */
|
||||
analog_unlock_private(p);
|
||||
@@ -601,83 +601,83 @@ static void analog_lock_sub_owner(struct analog_pvt *pvt, enum analog_sub sub_id
|
||||
|
||||
static int analog_off_hook(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->off_hook) {
|
||||
return p->calls->off_hook(p->chan_pvt);
|
||||
if (analog_callbacks.off_hook) {
|
||||
return analog_callbacks.off_hook(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void analog_set_needringing(struct analog_pvt *p, int value)
|
||||
{
|
||||
if (p->calls->set_needringing) {
|
||||
return p->calls->set_needringing(p->chan_pvt, value);
|
||||
if (analog_callbacks.set_needringing) {
|
||||
analog_callbacks.set_needringing(p->chan_pvt, value);
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
static void analog_set_polarity(struct analog_pvt *p, int value)
|
||||
{
|
||||
if (p->calls->set_polarity) {
|
||||
return p->calls->set_polarity(p->chan_pvt, value);
|
||||
if (analog_callbacks.set_polarity) {
|
||||
analog_callbacks.set_polarity(p->chan_pvt, value);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void analog_start_polarityswitch(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->start_polarityswitch) {
|
||||
return p->calls->start_polarityswitch(p->chan_pvt);
|
||||
if (analog_callbacks.start_polarityswitch) {
|
||||
analog_callbacks.start_polarityswitch(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
static void analog_answer_polarityswitch(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->answer_polarityswitch) {
|
||||
return p->calls->answer_polarityswitch(p->chan_pvt);
|
||||
if (analog_callbacks.answer_polarityswitch) {
|
||||
analog_callbacks.answer_polarityswitch(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_hangup_polarityswitch(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->hangup_polarityswitch) {
|
||||
return p->calls->hangup_polarityswitch(p->chan_pvt);
|
||||
if (analog_callbacks.hangup_polarityswitch) {
|
||||
analog_callbacks.hangup_polarityswitch(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static int analog_dsp_set_digitmode(struct analog_pvt *p, enum analog_dsp_digitmode mode)
|
||||
{
|
||||
if (p->calls->dsp_set_digitmode) {
|
||||
return p->calls->dsp_set_digitmode(p->chan_pvt, mode);
|
||||
if (analog_callbacks.dsp_set_digitmode) {
|
||||
return analog_callbacks.dsp_set_digitmode(p->chan_pvt, mode);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void analog_cb_handle_dtmf(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
|
||||
{
|
||||
if (p->calls->handle_dtmf) {
|
||||
p->calls->handle_dtmf(p->chan_pvt, ast, analog_index, dest);
|
||||
if (analog_callbacks.handle_dtmf) {
|
||||
analog_callbacks.handle_dtmf(p->chan_pvt, ast, analog_index, dest);
|
||||
}
|
||||
}
|
||||
|
||||
static int analog_wink(struct analog_pvt *p, enum analog_sub index)
|
||||
{
|
||||
if (p->calls->wink) {
|
||||
return p->calls->wink(p->chan_pvt, index);
|
||||
if (analog_callbacks.wink) {
|
||||
return analog_callbacks.wink(p->chan_pvt, index);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_has_voicemail(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->has_voicemail) {
|
||||
return p->calls->has_voicemail(p->chan_pvt);
|
||||
if (analog_callbacks.has_voicemail) {
|
||||
return analog_callbacks.has_voicemail(p->chan_pvt);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_is_dialing(struct analog_pvt *p, enum analog_sub index)
|
||||
{
|
||||
if (p->calls->is_dialing) {
|
||||
return p->calls->is_dialing(p->chan_pvt, index);
|
||||
if (analog_callbacks.is_dialing) {
|
||||
return analog_callbacks.is_dialing(p->chan_pvt, index);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -779,20 +779,20 @@ static int analog_update_conf(struct analog_pvt *p)
|
||||
for (x = 0; x < 3; x++) {
|
||||
/* Look for three way calls */
|
||||
if ((p->subs[x].allocd) && p->subs[x].inthreeway) {
|
||||
if (p->calls->conf_add) {
|
||||
p->calls->conf_add(p->chan_pvt, x);
|
||||
if (analog_callbacks.conf_add) {
|
||||
analog_callbacks.conf_add(p->chan_pvt, x);
|
||||
}
|
||||
needconf++;
|
||||
} else {
|
||||
if (p->calls->conf_del) {
|
||||
p->calls->conf_del(p->chan_pvt, x);
|
||||
if (analog_callbacks.conf_del) {
|
||||
analog_callbacks.conf_del(p->chan_pvt, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
ast_debug(1, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
|
||||
|
||||
if (p->calls->complete_conference_update) {
|
||||
p->calls->complete_conference_update(p->chan_pvt, needconf);
|
||||
if (analog_callbacks.complete_conference_update) {
|
||||
analog_callbacks.complete_conference_update(p->chan_pvt, needconf);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -887,8 +887,8 @@ int analog_available(struct analog_pvt *p)
|
||||
static int analog_stop_callwait(struct analog_pvt *p)
|
||||
{
|
||||
p->callwaitcas = 0;
|
||||
if (p->calls->stop_callwait) {
|
||||
return p->calls->stop_callwait(p->chan_pvt);
|
||||
if (analog_callbacks.stop_callwait) {
|
||||
return analog_callbacks.stop_callwait(p->chan_pvt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -896,8 +896,8 @@ static int analog_stop_callwait(struct analog_pvt *p)
|
||||
static int analog_callwait(struct analog_pvt *p)
|
||||
{
|
||||
p->callwaitcas = p->callwaitingcallerid;
|
||||
if (p->calls->callwait) {
|
||||
return p->calls->callwait(p->chan_pvt);
|
||||
if (analog_callbacks.callwait) {
|
||||
return analog_callbacks.callwait(p->chan_pvt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -905,54 +905,53 @@ static int analog_callwait(struct analog_pvt *p)
|
||||
static void analog_set_callwaiting(struct analog_pvt *p, int callwaiting_enable)
|
||||
{
|
||||
p->callwaiting = callwaiting_enable;
|
||||
if (p->calls->set_callwaiting) {
|
||||
p->calls->set_callwaiting(p->chan_pvt, callwaiting_enable);
|
||||
if (analog_callbacks.set_callwaiting) {
|
||||
analog_callbacks.set_callwaiting(p->chan_pvt, callwaiting_enable);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_set_cadence(struct analog_pvt *p, struct ast_channel *chan)
|
||||
{
|
||||
if (p->calls->set_cadence) {
|
||||
return p->calls->set_cadence(p->chan_pvt, &p->cidrings, chan);
|
||||
if (analog_callbacks.set_cadence) {
|
||||
analog_callbacks.set_cadence(p->chan_pvt, &p->cidrings, chan);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_set_dialing(struct analog_pvt *p, int is_dialing)
|
||||
{
|
||||
p->dialing = is_dialing;
|
||||
if (p->calls->set_dialing) {
|
||||
return p->calls->set_dialing(p->chan_pvt, is_dialing);
|
||||
if (analog_callbacks.set_dialing) {
|
||||
analog_callbacks.set_dialing(p->chan_pvt, is_dialing);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_set_alarm(struct analog_pvt *p, int in_alarm)
|
||||
{
|
||||
p->inalarm = in_alarm;
|
||||
if (p->calls->set_alarm) {
|
||||
return p->calls->set_alarm(p->chan_pvt, in_alarm);
|
||||
if (analog_callbacks.set_alarm) {
|
||||
analog_callbacks.set_alarm(p->chan_pvt, in_alarm);
|
||||
}
|
||||
}
|
||||
|
||||
static void analog_set_ringtimeout(struct analog_pvt *p, int ringt)
|
||||
{
|
||||
p->ringt = ringt;
|
||||
if (!p->calls->set_ringtimeout) {
|
||||
return;
|
||||
if (analog_callbacks.set_ringtimeout) {
|
||||
analog_callbacks.set_ringtimeout(p->chan_pvt, ringt);
|
||||
}
|
||||
p->calls->set_ringtimeout(p->chan_pvt, ringt);
|
||||
}
|
||||
|
||||
static void analog_set_waitingfordt(struct analog_pvt *p, struct ast_channel *ast)
|
||||
{
|
||||
if (p->calls->set_waitingfordt) {
|
||||
return p->calls->set_waitingfordt(p->chan_pvt, ast);
|
||||
if (analog_callbacks.set_waitingfordt) {
|
||||
analog_callbacks.set_waitingfordt(p->chan_pvt, ast);
|
||||
}
|
||||
}
|
||||
|
||||
static int analog_check_waitingfordt(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->check_waitingfordt) {
|
||||
return p->calls->check_waitingfordt(p->chan_pvt);
|
||||
if (analog_callbacks.check_waitingfordt) {
|
||||
return analog_callbacks.check_waitingfordt(p->chan_pvt);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -960,16 +959,15 @@ static int analog_check_waitingfordt(struct analog_pvt *p)
|
||||
|
||||
static void analog_set_confirmanswer(struct analog_pvt *p, int flag)
|
||||
{
|
||||
if (!p->calls->set_confirmanswer) {
|
||||
return;
|
||||
if (analog_callbacks.set_confirmanswer) {
|
||||
analog_callbacks.set_confirmanswer(p->chan_pvt, flag);
|
||||
}
|
||||
p->calls->set_confirmanswer(p->chan_pvt, flag);
|
||||
}
|
||||
|
||||
static int analog_check_confirmanswer(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->check_confirmanswer) {
|
||||
return p->calls->check_confirmanswer(p->chan_pvt);
|
||||
if (analog_callbacks.check_confirmanswer) {
|
||||
return analog_callbacks.check_confirmanswer(p->chan_pvt);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -977,34 +975,31 @@ static int analog_check_confirmanswer(struct analog_pvt *p)
|
||||
|
||||
static void analog_cancel_cidspill(struct analog_pvt *p)
|
||||
{
|
||||
if (!p->calls->cancel_cidspill) {
|
||||
return;
|
||||
if (analog_callbacks.cancel_cidspill) {
|
||||
analog_callbacks.cancel_cidspill(p->chan_pvt);
|
||||
}
|
||||
|
||||
p->calls->cancel_cidspill(p->chan_pvt);
|
||||
}
|
||||
|
||||
static int analog_confmute(struct analog_pvt *p, int mute)
|
||||
{
|
||||
if (p->calls->confmute) {
|
||||
return p->calls->confmute(p->chan_pvt, mute);
|
||||
if (analog_callbacks.confmute) {
|
||||
return analog_callbacks.confmute(p->chan_pvt, mute);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void analog_set_pulsedial(struct analog_pvt *p, int flag)
|
||||
{
|
||||
if (!p->calls->set_pulsedial) {
|
||||
return;
|
||||
if (analog_callbacks.set_pulsedial) {
|
||||
analog_callbacks.set_pulsedial(p->chan_pvt, flag);
|
||||
}
|
||||
p->calls->set_pulsedial(p->chan_pvt, flag);
|
||||
}
|
||||
|
||||
static int analog_set_linear_mode(struct analog_pvt *p, enum analog_sub sub, int linear_mode)
|
||||
{
|
||||
if (p->calls->set_linear_mode) {
|
||||
if (analog_callbacks.set_linear_mode) {
|
||||
/* Return provides old linear_mode setting or error indication */
|
||||
return p->calls->set_linear_mode(p->chan_pvt, sub, linear_mode);
|
||||
return analog_callbacks.set_linear_mode(p->chan_pvt, sub, linear_mode);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -1012,8 +1007,8 @@ static int analog_set_linear_mode(struct analog_pvt *p, enum analog_sub sub, int
|
||||
static void analog_set_inthreeway(struct analog_pvt *p, enum analog_sub sub, int inthreeway)
|
||||
{
|
||||
p->subs[sub].inthreeway = inthreeway;
|
||||
if (p->calls->set_inthreeway) {
|
||||
p->calls->set_inthreeway(p->chan_pvt, sub, inthreeway);
|
||||
if (analog_callbacks.set_inthreeway) {
|
||||
analog_callbacks.set_inthreeway(p->chan_pvt, sub, inthreeway);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1667,35 +1662,31 @@ static int analog_my_getsigstr(struct ast_channel *chan, char *str, const char *
|
||||
|
||||
static int analog_handle_notify_message(struct ast_channel *chan, struct analog_pvt *p, int cid_flags, int neon_mwievent)
|
||||
{
|
||||
if (p->calls->handle_notify_message) {
|
||||
p->calls->handle_notify_message(chan, p->chan_pvt, cid_flags, neon_mwievent);
|
||||
if (analog_callbacks.handle_notify_message) {
|
||||
analog_callbacks.handle_notify_message(chan, p->chan_pvt, cid_flags, neon_mwievent);
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_increase_ss_count(struct analog_pvt *p)
|
||||
static void analog_increase_ss_count(void)
|
||||
{
|
||||
if (p->calls->increase_ss_count) {
|
||||
p->calls->increase_ss_count();
|
||||
return 0;
|
||||
if (analog_callbacks.increase_ss_count) {
|
||||
analog_callbacks.increase_ss_count();
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_decrease_ss_count(struct analog_pvt *p)
|
||||
static void analog_decrease_ss_count(void)
|
||||
{
|
||||
if (p->calls->decrease_ss_count) {
|
||||
p->calls->decrease_ss_count();
|
||||
return 0;
|
||||
if (analog_callbacks.decrease_ss_count) {
|
||||
analog_callbacks.decrease_ss_count();
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int analog_distinctive_ring(struct ast_channel *chan, struct analog_pvt *p, int idx, int *ringdata)
|
||||
{
|
||||
if (p->calls->distinctive_ring) {
|
||||
return p->calls->distinctive_ring(chan, p->chan_pvt, idx, ringdata);
|
||||
if (analog_callbacks.distinctive_ring) {
|
||||
return analog_callbacks.distinctive_ring(chan, p->chan_pvt, idx, ringdata);
|
||||
}
|
||||
return -1;
|
||||
|
||||
@@ -1703,23 +1694,23 @@ static int analog_distinctive_ring(struct ast_channel *chan, struct analog_pvt *
|
||||
|
||||
static void analog_get_and_handle_alarms(struct analog_pvt *p)
|
||||
{
|
||||
if (p->calls->get_and_handle_alarms) {
|
||||
return p->calls->get_and_handle_alarms(p->chan_pvt);
|
||||
if (analog_callbacks.get_and_handle_alarms) {
|
||||
analog_callbacks.get_and_handle_alarms(p->chan_pvt);
|
||||
}
|
||||
}
|
||||
|
||||
static void *analog_get_bridged_channel(struct analog_pvt *p, struct ast_channel *chan)
|
||||
static void *analog_get_bridged_channel(struct ast_channel *chan)
|
||||
{
|
||||
if (p->calls->get_sigpvt_bridged_channel) {
|
||||
return p->calls->get_sigpvt_bridged_channel(chan);
|
||||
if (analog_callbacks.get_sigpvt_bridged_channel) {
|
||||
return analog_callbacks.get_sigpvt_bridged_channel(chan);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int analog_get_sub_fd(struct analog_pvt *p, enum analog_sub sub)
|
||||
{
|
||||
if (p->calls->get_sub_fd) {
|
||||
return p->calls->get_sub_fd(p->chan_pvt, sub);
|
||||
if (analog_callbacks.get_sub_fd) {
|
||||
return analog_callbacks.get_sub_fd(p->chan_pvt, sub);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -1775,7 +1766,7 @@ static void *__analog_ss_thread(void *data)
|
||||
int idx;
|
||||
struct ast_callid *callid;
|
||||
|
||||
analog_increase_ss_count(p);
|
||||
analog_increase_ss_count();
|
||||
|
||||
ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
|
||||
|
||||
@@ -2323,7 +2314,7 @@ static void *__analog_ss_thread(void *data)
|
||||
struct analog_pvt *pbridge = NULL;
|
||||
/* set up the private struct of the bridged one, if any */
|
||||
if (nbridge) {
|
||||
pbridge = analog_get_bridged_channel(p, nbridge);
|
||||
pbridge = analog_get_bridged_channel(nbridge);
|
||||
}
|
||||
if (pbridge && ISTRUNK(pbridge)) {
|
||||
/* Clear out the dial buffer */
|
||||
@@ -2651,7 +2642,7 @@ quit:
|
||||
if (smdi_msg) {
|
||||
ASTOBJ_UNREF(smdi_msg, ast_smdi_md_message_destroy);
|
||||
}
|
||||
analog_decrease_ss_count(p);
|
||||
analog_decrease_ss_count();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -3940,7 +3931,7 @@ void *analog_handle_init_event(struct analog_pvt *i, int event)
|
||||
}
|
||||
|
||||
|
||||
struct analog_pvt *analog_new(enum analog_sigtype signallingtype, struct analog_callback *c, void *private_data)
|
||||
struct analog_pvt *analog_new(enum analog_sigtype signallingtype, void *private_data)
|
||||
{
|
||||
struct analog_pvt *p;
|
||||
|
||||
@@ -3949,7 +3940,6 @@ struct analog_pvt *analog_new(enum analog_sigtype signallingtype, struct analog_
|
||||
return p;
|
||||
}
|
||||
|
||||
p->calls = c;
|
||||
p->outsigmod = ANALOG_SIG_NONE;
|
||||
p->sig = signallingtype;
|
||||
p->chan_pvt = private_data;
|
||||
|
||||
Reference in New Issue
Block a user