diff options
| -rw-r--r-- | channels/Makefile | 1 | ||||
| -rw-r--r-- | channels/chan_dahdi.c | 2726 | ||||
| -rw-r--r-- | channels/sig_analog.c | 3262 | ||||
| -rw-r--r-- | channels/sig_analog.h | 329 |
4 files changed, 5478 insertions, 840 deletions
diff --git a/channels/Makefile b/channels/Makefile index cb7676dcf..6e03b22ff 100644 --- a/channels/Makefile +++ b/channels/Makefile @@ -69,6 +69,7 @@ dist-clean:: rm -f h323/Makefile $(if $(filter chan_iax2,$(EMBEDDED_MODS)),modules.link,chan_iax2.so): iax2-parser.o iax2-provision.o +$(if $(filter chan_dahdi,$(EMBEDDED_MODS)),modules.link,chan_dahdi.so): sig_analog.o ifneq ($(filter chan_h323,$(EMBEDDED_MODS)),) modules.link: h323/libchanh323.a diff --git a/channels/chan_dahdi.c b/channels/chan_dahdi.c index fb255956e..9e4b48727 100644 --- a/channels/chan_dahdi.c +++ b/channels/chan_dahdi.c @@ -62,6 +62,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include <dahdi/user.h> #include <dahdi/tonezone.h> +#include "sig_analog.h" #ifdef HAVE_PRI #include <libpri.h> @@ -468,6 +469,8 @@ static enum ast_bridge_result dahdi_bridge(struct ast_channel *c0, struct ast_ch static int dahdi_sendtext(struct ast_channel *c, const char *text); +static int analog_lib_handles(int signalling, int radio, int oprmode); + static void mwi_event_cb(const struct ast_event *event, void *userdata) { /* This module does not handle MWI in an event-based manner. However, it @@ -753,6 +756,7 @@ struct mwisend_info { static struct dahdi_pvt { ast_mutex_t lock; + struct callerid_state *cs; struct ast_channel *owner; /*!< Our current active owner (if applicable) */ /*!< Up to three channels can be associated with this call */ @@ -1333,6 +1337,7 @@ static struct dahdi_pvt { char begindigit; /*! \brief TRUE if confrence is muted. */ int muting; + void *sig_pvt; } *iflist = NULL, *ifend = NULL; /*! \brief Channel configuration from chan_dahdi.conf . @@ -1528,6 +1533,911 @@ static const struct ast_channel_tech dahdi_tech = { #define GET_CHANNEL(p) ((p)->channel) #endif +static enum analog_sigtype dahdisig_to_analogsig(int sig) +{ + switch (sig) { + case SIG_FXOLS: + return ANALOG_SIG_FXOLS; + case SIG_FXOGS: + return ANALOG_SIG_FXOGS; + case SIG_FXOKS: + return ANALOG_SIG_FXOKS; + case SIG_FXSLS: + return ANALOG_SIG_FXSLS; + case SIG_FXSGS: + return ANALOG_SIG_FXSGS; + case SIG_FXSKS: + return ANALOG_SIG_FXSKS; + case SIG_EMWINK: + return ANALOG_SIG_EMWINK; + case SIG_EM: + return ANALOG_SIG_EM; + case SIG_EM_E1: + return ANALOG_SIG_EM_E1; + case SIG_FEATD: + return ANALOG_SIG_FEATD; + case SIG_FEATDMF: + return ANALOG_SIG_FEATDMF; + case SIG_E911: + return SIG_E911; + case SIG_FGC_CAMA: + return ANALOG_SIG_FGC_CAMA; + case SIG_FGC_CAMAMF: + return ANALOG_SIG_FGC_CAMAMF; + case SIG_FEATB: + return ANALOG_SIG_FEATB; + case SIG_SFWINK: + return ANALOG_SIG_SFWINK; + case SIG_SF: + return ANALOG_SIG_SF; + case SIG_SF_FEATD: + return ANALOG_SIG_SF_FEATD; + case SIG_SF_FEATDMF: + return ANALOG_SIG_SF_FEATDMF; + case SIG_FEATDMF_TA: + return ANALOG_SIG_FEATDMF_TA; + case SIG_SF_FEATB: + return ANALOG_SIG_FEATB; + default: + return -1; + } +} + + +static int analog_tone_to_dahditone(enum analog_tone tone) +{ + switch (tone) { + case ANALOG_TONE_RINGTONE: + return DAHDI_TONE_RINGTONE; + case ANALOG_TONE_STUTTER: + return DAHDI_TONE_STUTTER; + case ANALOG_TONE_CONGESTION: + return DAHDI_TONE_CONGESTION; + case ANALOG_TONE_DIALTONE: + return DAHDI_TONE_DIALTONE; + case ANALOG_TONE_DIALRECALL: + return DAHDI_TONE_DIALRECALL; + case ANALOG_TONE_INFO: + return DAHDI_TONE_INFO; + default: + return -1; + } +} + +static int analogsub_to_dahdisub(enum analog_sub analogsub) +{ + int index; + + switch (analogsub) { + case ANALOG_SUB_REAL: + index = SUB_REAL; + break; + case ANALOG_SUB_CALLWAIT: + index = SUB_CALLWAIT; + break; + case ANALOG_SUB_THREEWAY: + index = SUB_THREEWAY; + break; + default: + ast_log(LOG_ERROR, "Unidentified sub!\n"); + index = SUB_REAL; + } + + return index; +} + +static enum analog_event dahdievent_to_analogevent(int event); +static int bump_gains(struct dahdi_pvt *p); +static int dahdi_setlinear(int dfd, int linear); + +static int my_start_cid_detect(void *pvt, int cid_signalling) +{ + struct dahdi_pvt *p = pvt; + int index = SUB_REAL; + p->cs = callerid_new(cid_signalling); + if (!p->cs) { + ast_log(LOG_ERROR, "Unable to alloc callerid\n"); + return -1; + } + bump_gains(p); + dahdi_setlinear(p->subs[index].dfd, 0); + + return 0; +} + +static int my_stop_cid_detect(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int index = SUB_REAL; + if (p->cs) + callerid_free(p->cs); + dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear); + return 0; +} + +static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout) +{ + struct dahdi_pvt *p = pvt; + struct pollfd poller; + char *name, *num; + int index = SUB_REAL; + int res; + unsigned char buf[256]; + int flags; + + poller.fd = p->subs[SUB_REAL].dfd; + poller.events = POLLPRI | POLLIN; + poller.revents = 0; + + res = poll(&poller, 1, timeout); + + if (poller.revents & POLLPRI) { + *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd)); + return 1; + } + + if (poller.revents & POLLIN) { + /*** NOTES ***/ + /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function + * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until + * either a timeout occurss or CID is detected (returns 0). returning 1 should be event received, and -1 should be fail + * and die */ + res = read(p->subs[index].dfd, buf, sizeof(buf)); + if (res < 0) { + if (errno != ELAST) { + ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno)); + callerid_free(p->cs); + return -1; + } + } + res = callerid_feed(p->cs, buf, res, AST_LAW(p)); + if (res < 0) { + ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno)); + return -1; + } + + if (res == 1) { + callerid_get(p->cs, &name, &num, &flags); + if (name) + ast_copy_string(namebuf, name, ANALOG_MAX_CID); + if (num) + ast_copy_string(numbuf, num, ANALOG_MAX_CID); + + ast_log(LOG_DEBUG, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags); + return 0; + } + } + + *ev = ANALOG_EVENT_NONE; + return 1; +} + +static int send_callerid(struct dahdi_pvt *p); + +static int my_stop_callwait(void *pvt) +{ + struct dahdi_pvt *p = pvt; + p->callwaitingrepeat = 0; + p->cidcwexpire = 0; + + return 0; +} + +static int save_conference(struct dahdi_pvt *p); + +static int my_callwait(void *pvt) +{ + struct dahdi_pvt *p = pvt; + p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES; + if (p->cidspill) { + ast_log(LOG_WARNING, "Spill already exists?!?\n"); + free(p->cidspill); + } + if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4))) + return -1; + save_conference(p); + /* Silence */ + memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4); + if (!p->callwaitrings && p->callwaitingcallerid) { + ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p)); + p->callwaitcas = 1; + p->cidlen = 2400 + 680 + READ_SIZE * 4; + } else { + ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p)); + p->callwaitcas = 0; + p->cidlen = 2400 + READ_SIZE * 4; + } + p->cidpos = 0; + send_callerid(p); + + return 0; +} + +static int my_send_callerid(void *pvt, int cwcid, struct ast_callerid *cid) +{ + struct dahdi_pvt *p = pvt; + + ast_log(LOG_ERROR, "Starting cid spill\n"); + + if (p->cidspill) { + ast_log(LOG_WARNING, "cidspill already exists??\n"); + free(p->cidspill); + } + + if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) { + if (cwcid == 0) { + p->cidlen = ast_callerid_generate(p->cidspill, cid->cid_name, cid->cid_num, AST_LAW(p)); + } else { + p->callwaitcas = 0; + p->cidcwexpire = 0; + p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, cid->cid_name, cid->cid_num, AST_LAW(p)); + p->cidlen += READ_SIZE * 4; + } + p->cidpos = 0; + send_callerid(p); + } + return 0; +} + +static int my_dsp_reset_and_flush_digits(void *pvt) +{ + struct dahdi_pvt *p = pvt; + if (p->dsp) + ast_dsp_digitreset(p->dsp); + + return 0; +} + +static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode) +{ + struct dahdi_pvt *p = pvt; + + if (p->channel == CHAN_PSEUDO) + ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n"); + + if (mode == ANALOG_DIGITMODE_DTMF) { + /* If we do hardware dtmf, no need for a DSP */ + if (p->hardwaredtmf) { + if (p->dsp) { + ast_dsp_free(p->dsp); + p->dsp = NULL; + } + return 0; + } + + if (!p->dsp) { + p->dsp = ast_dsp_new(); + if (!p->dsp) { + ast_log(LOG_ERROR, "Unable to allocate DSP\n"); + return -1; + } + } + + ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax); + } else if (mode == ANALOG_DIGITMODE_MF) { + if (!p->dsp) { + p->dsp = ast_dsp_new(); + if (!p->dsp) { + ast_log(LOG_ERROR, "Unable to allocate DSP\n"); + return -1; + } + } + ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax); + } + return 0; +} + +static int dahdi_wink(struct dahdi_pvt *p, int index); + +static int my_wink(void *pvt, enum analog_sub sub) +{ + struct dahdi_pvt *p = pvt; + int index = analogsub_to_dahdisub(sub); + if (index != SUB_REAL) { + ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n"); + } + return dahdi_wink(p, index); +} + +static void wakeup_sub(struct dahdi_pvt *p, int a, struct dahdi_pri *pri); + +static int reset_conf(struct dahdi_pvt *p); + +static inline int dahdi_confmute(struct dahdi_pvt *p, int muted); + +static void my_handle_dtmfup(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest) +{ + struct ast_frame *f = *dest; + struct dahdi_pvt *p = pvt; + int idx = analogsub_to_dahdisub(analog_index); + + ast_debug(1, "DTMF digit: %c on %s\n", f->subclass, ast->name); + + if (f->subclass == 'f') { + /* Fax tone -- Handle and return NULL */ + if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) { + /* If faxbuffers are configured, use them for the fax transmission */ + if (p->usefaxbuffers && !p->bufferoverrideinuse) { + struct dahdi_bufferinfo bi = { + .txbufpolicy = p->faxbuf_policy, + .bufsize = p->bufsize, + .numbufs = p->faxbuf_no + }; + int res; + + if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) { + ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast->name, strerror(errno)); + } else { + p->bufferoverrideinuse = 1; + } + } + p->faxhandled = 1; + if (strcmp(ast->exten, "fax")) { + const char *target_context = S_OR(ast->macrocontext, ast->context); + + /* We need to unlock 'ast' here because ast_exists_extension has the + * potential to start autoservice on the channel. Such action is prone + * to deadlock. + */ + ast_mutex_unlock(&p->lock); + ast_channel_unlock(ast); + if (ast_exists_extension(ast, target_context, "fax", 1, ast->cid.cid_num)) { + ast_channel_lock(ast); + ast_mutex_lock(&p->lock); + ast_verb(3, "Redirecting %s to fax extension\n", ast->name); + /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */ + pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast->exten); + if (ast_async_goto(ast, target_context, "fax", 1)) + ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast->name, target_context); + } else { + ast_channel_lock(ast); + ast_mutex_lock(&p->lock); + ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n"); + } + } else { + ast_debug(1, "Already in a fax extension, not redirecting\n"); + } + } else { + ast_debug(1, "Fax already handled\n"); + } + dahdi_confmute(p, 0); + p->subs[idx].f.frametype = AST_FRAME_NULL; + p->subs[idx].f.subclass = 0; + *dest = &p->subs[idx].f; + } +} + +static void my_lock_private(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + ast_mutex_lock(&p->lock); +} + +static void my_unlock_private(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + ast_mutex_unlock(&p->lock); +} + +static void my_increase_ss_count(void) +{ + ast_mutex_lock(&ss_thread_lock); + ss_thread_count++; + ast_mutex_unlock(&ss_thread_lock); +} + +static void my_decrease_ss_count(void) +{ + ast_mutex_lock(&ss_thread_lock); + ss_thread_count--; + ast_cond_signal(&ss_thread_complete); + ast_mutex_unlock(&ss_thread_lock); +} + +static void my_all_subchannels_hungup(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int res, law; + + p->faxhandled = 0; + p->didtdd = 0; + + if (p->dsp) { + ast_dsp_free(p->dsp); + p->dsp = NULL; + } + + law = DAHDI_LAW_DEFAULT; + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law); + if (res < 0) + ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno)); + + dahdi_setlinear(p->subs[SUB_REAL].dfd, 0); + +#if 1 + { + int i; + p->owner = NULL; + /* Cleanup owners here */ + for (i = 0; i < 3; i++) { + p->subs[i].owner = NULL; + } + } +#endif + + reset_conf(p); + if (num_restart_pending == 0) { + restart_monitor(); + } +} + +static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index); + +static int my_conf_del(void *pvt, enum analog_sub sub) +{ + struct dahdi_pvt *p = pvt; + int x = analogsub_to_dahdisub(sub); + + return conf_del(p, &p->subs[x], x); +} + +static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel); + +static int my_conf_add(void *pvt, enum analog_sub sub) +{ + struct dahdi_pvt *p = pvt; + int x = analogsub_to_dahdisub(sub); + + return conf_add(p, &p->subs[x], x, 0); +} + +static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out); + +static int my_complete_conference_update(void *pvt, int needconference) +{ + struct dahdi_pvt *p = pvt; + int needconf = needconference; + int x; + int useslavenative; + struct dahdi_pvt *slave = NULL; + + useslavenative = isslavenative(p, &slave); + + /* If we have a slave, add him to our conference now. or DAX + if this is slave native */ + for (x = 0; x < MAX_SLAVES; x++) { + if (p->slaves[x]) { + if (useslavenative) + conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p)); + else { + conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0); + needconf++; + } + } + } + /* If we're supposed to be in there, do so now */ + if (p->inconference && !p->subs[SUB_REAL].inthreeway) { + if (useslavenative) + conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave)); + else { + conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0); + needconf++; + } + } + /* If we have a master, add ourselves to his conference */ + if (p->master) { + if (isslavenative(p->master, NULL)) { + conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master)); + } else { + conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0); + } + } + if (!needconf) { + /* Nobody is left (or should be left) in our conference. + Kill it. */ + p->confno = -1; + } + + return 0; +} + +static int check_for_conference(struct dahdi_pvt *p); + +static int my_check_for_conference(void *pvt) +{ + struct dahdi_pvt *p = pvt; + return check_for_conference(p); +} + +static void my_swap_subchannels(void *pvt, enum analog_sub a, struct ast_channel *ast_a, enum analog_sub b, struct ast_channel *ast_b) +{ + struct dahdi_pvt *p = pvt; + int da, db; + int tchan; + + da = analogsub_to_dahdisub(a); + db = analogsub_to_dahdisub(b); + + tchan = p->subs[da].chan; + + p->subs[da].chan = p->subs[db].chan; + + p->subs[db].chan = tchan; + + if (ast_a) + ast_a->fds[0] = p->subs[da].dfd; + if (ast_b) + ast_b->fds[0] = p->subs[db].dfd; + + p->subs[da].owner = ast_a; + p->subs[db].owner = ast_b; + + wakeup_sub(p, a, NULL); + wakeup_sub(p, b, NULL); + + return; +} + +static struct ast_channel *dahdi_new(struct dahdi_pvt *, int, int, int, int, int); + +static struct ast_channel * my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub) +{ + struct dahdi_pvt *p = pvt; + int dsub = analogsub_to_dahdisub(sub); + + return dahdi_new(p, state, startpbx, dsub, 0, 0); +} + +static int unalloc_sub(struct dahdi_pvt *p, int x); + +static int my_unallocate_sub(void *pvt, enum analog_sub analogsub) +{ + struct dahdi_pvt *p = pvt; + + return unalloc_sub(p, analogsub_to_dahdisub(analogsub)); +} + +static int alloc_sub(struct dahdi_pvt *p, int x); + +static int my_allocate_sub(void *pvt, enum analog_sub analogsub) +{ + struct dahdi_pvt *p = pvt; + + return alloc_sub(p, analogsub_to_dahdisub(analogsub)); +} + +static int has_voicemail(struct dahdi_pvt *p); + +static int my_has_voicemail(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + return has_voicemail(p); +} + +static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone) +{ + struct dahdi_pvt *p = pvt; + int index; + + index = analogsub_to_dahdisub(sub); + + return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone)); +} + +static enum analog_event dahdievent_to_analogevent(int event) +{ + enum analog_event res = ANALOG_EVENT_ERROR; + + switch (event) { + case DAHDI_EVENT_DIALCOMPLETE: + res = ANALOG_EVENT_DIALCOMPLETE; + break; + case DAHDI_EVENT_WINKFLASH: + res = ANALOG_EVENT_WINKFLASH; + break; + case DAHDI_EVENT_ONHOOK: + res = ANALOG_EVENT_ONHOOK; + break; + case DAHDI_EVENT_RINGOFFHOOK: + res = ANALOG_EVENT_RINGOFFHOOK; + break; + case DAHDI_EVENT_ALARM: + res = ANALOG_EVENT_ALARM; + break; + case DAHDI_EVENT_NOALARM: + res = ANALOG_EVENT_NOALARM; + break; + case DAHDI_EVENT_HOOKCOMPLETE: + res = ANALOG_EVENT_HOOKCOMPLETE; + break; + case DAHDI_EVENT_POLARITY: + res = ANALOG_EVENT_POLARITY; + break; + case DAHDI_EVENT_RINGERON: + res = ANALOG_EVENT_RINGERON; + break; + case DAHDI_EVENT_RINGEROFF: + res = ANALOG_EVENT_RINGEROFF; + break; + case DAHDI_EVENT_RINGBEGIN: + res = ANALOG_EVENT_RINGBEGIN; + break; + case DAHDI_EVENT_PULSE_START: + res = ANALOG_EVENT_PULSE_START; + break; + case DAHDI_EVENT_NEONMWI_ACTIVE: + res = ANALOG_EVENT_NEONMWI_ACTIVE; + break; + case DAHDI_EVENT_NEONMWI_INACTIVE: + res = ANALOG_EVENT_NEONMWI_INACTIVE; + break; + } + + return res; +} + +static inline int dahdi_wait_event(int fd); + +static int my_wait_event(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + return dahdi_wait_event(p->subs[SUB_REAL].dfd); +} + +static int my_get_event(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int res; + + if (p->fake_event) { + res = p->fake_event; + p->fake_event = 0; + } else + res = dahdi_get_event(p->subs[SUB_REAL].dfd); + + return dahdievent_to_analogevent(res); +} + +static int my_is_off_hook(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int res; + struct dahdi_params par; + + if (p->subs[SUB_REAL].dfd > -1) + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par); + else { + /* Assume not off hook on CVRS */ + res = 0; + par.rxisoffhook = 0; + } + if (res) { + ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno)); + } + + return (par.rxbits > -1) || par.rxisoffhook; +} + +static void dahdi_enable_ec(struct dahdi_pvt *p); +static void dahdi_disable_ec(struct dahdi_pvt *p); + +static int my_set_echocanceller(void *pvt, int enable) +{ + struct dahdi_pvt *p = pvt; + + if (enable) + dahdi_enable_ec(p); + else + dahdi_disable_ec(p); + + return 0; +} + +static int dahdi_ring_phone(struct dahdi_pvt *p); + +static int my_ring(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + return dahdi_ring_phone(p); +} + +static inline int dahdi_set_hook(int fd, int hs); + +static int my_off_hook(void *pvt) +{ + struct dahdi_pvt *p = pvt; + return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK); +} + +static int my_start(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int x = DAHDI_START; + + return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); +} + +static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop) +{ + int index = analogsub_to_dahdisub(sub); + int res; + struct dahdi_pvt *p = pvt; + struct dahdi_dialoperation ddop; + + if (dop->op != ANALOG_DIAL_OP_REPLACE) { + ast_log(LOG_ERROR, "Fix the dial_digits callback!\n"); + return -1; + } + + if (sub != ANALOG_SUB_REAL) + printf("Trying to dial digits on sub %d\n", sub); + + ddop.op = DAHDI_DIAL_OP_REPLACE; + strncpy(ddop.dialstr, dop->dialstr, sizeof(ddop.dialstr)); + + printf("Dialing %s on %d\n", ddop.dialstr, p->channel); + + res = ioctl(p->subs[index].dfd, DAHDI_DIAL, &ddop); + + if (res == -1) + ast_log(LOG_DEBUG, "DAHDI_DIAL ioctl failed on %s: %s\n", p->owner->name, strerror(errno)); + + return res; +} + +static void dahdi_train_ec(struct dahdi_pvt *p); + +static int my_train_echocanceller(void *pvt) +{ + struct dahdi_pvt *p = pvt; + + dahdi_train_ec(p); + + return 0; +} + +static int my_is_dialing(void *pvt, enum analog_sub sub) +{ + struct dahdi_pvt *p = pvt; + int index; + int x; + + index = analogsub_to_dahdisub(sub); + + if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) { + ast_log(LOG_DEBUG, "DAHDI_DIALING ioctl failed!\n"); + return -1; + } + + return x; +} + +static int my_on_hook(void *pvt) +{ + struct dahdi_pvt *p = pvt; + int x = DAHDI_ONHOOK; + + return ioctl(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_HOOK, &x); +} + +/*! + * \brief Send MWI state change + * + * \arg mailbox_full This is the mailbox associated with the FXO line that the + * MWI state has changed on. + * \arg thereornot This argument should simply be set to 1 or 0, to indicate + * whether there are messages waiting or not. + * + * \return nothing + * + * This function does two things: + * + * 1) It generates an internal Asterisk event notifying any other module that + * cares about MWI that the state of a mailbox has changed. + * + * 2) It runs the script specified by the mwimonitornotify option to allow + * some custom handling of the state change. + */ +static void notify_message(char *mailbox_full, int thereornot) +{ + char s[sizeof(mwimonitornotify) + 80]; + struct ast_event *event; + char *mailbox, *context; + + /* Strip off @default */ + context = mailbox = ast_strdupa(mailbox_full); + strsep(&context, "@"); + if (ast_strlen_zero(context)) + context = "default"; + + if (!(event = ast_event_new(AST_EVENT_MWI, + AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox, + AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context, + AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot, + AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot, + AST_EVENT_IE_END))) { + return; + } + + ast_event_queue_and_cache(event); + + if (!ast_strlen_zero(mailbox) && !ast_strlen_zero(mwimonitornotify)) { + snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot); + ast_safe_system(s); + } +} + +static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent) +{ + struct dahdi_pvt *p = pvt; + + if (neon_mwievent > -1 && !p->mwimonitor_neon) + return; + + if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) { + ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox); + notify_message(p->mailbox, 1); + } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) { + ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox); + notify_message(p->mailbox, 0); + } + /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */ + /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */ + if (neon_mwievent == -1 && p->mwimonitor_rpas) { + ast_hangup(chan); + return; + } +} + + +static const char *event2str(int event); + +static struct analog_callback dahdi_analog_callbacks = +{ + .play_tone = my_play_tone, + .get_event = my_get_event, + .wait_event = my_wait_event, + .is_off_hook = my_is_off_hook, + .set_echocanceller = my_set_echocanceller, + .ring = my_ring, + .off_hook = my_off_hook, + .dial_digits = my_dial_digits, + .train_echocanceller = my_train_echocanceller, + .on_hook = my_on_hook, + .is_dialing = my_is_dialing, + .allocate_sub = my_allocate_sub, + .unallocate_sub = my_unallocate_sub, + .swap_subs = my_swap_subchannels, + .has_voicemail = my_has_voicemail, + .check_for_conference = my_check_for_conference, + .conf_add = my_conf_add, + .conf_del = my_conf_del, + .complete_conference_update = my_complete_conference_update, + .start = my_start, + .all_subchannels_hungup = my_all_subchannels_hungup, + .lock_private = my_lock_private, + .unlock_private = my_unlock_private, + .handle_dtmfup = my_handle_dtmfup, + .wink = my_wink, + .new_ast_channel = my_new_analog_ast_channel, + .dsp_set_digitmode = my_dsp_set_digitmode, + .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits, + .send_callerid = my_send_callerid, + .callwait = my_callwait, + .stop_callwait = my_stop_callwait, + .get_callerid = my_get_callerid, + .start_cid_detect = my_start_cid_detect, + .stop_cid_detect = my_stop_cid_detect, + .handle_notify_message = my_handle_notify_message, + .increase_ss_count = my_increase_ss_count, + .decrease_ss_count = my_decrease_ss_count, +}; + struct dahdi_pvt *round_robin[32]; #if defined(HAVE_PRI) @@ -2579,6 +3489,45 @@ static char *dahdi_sig2str(int sig) } } +int analog_lib_handles(int signalling, int radio, int oprmode) +{ + switch (signalling) { + case SIG_FXOLS: + case SIG_FXOGS: + case SIG_FXOKS: + case SIG_FXSLS: + case SIG_FXSGS: + case SIG_FXSKS: + case SIG_EMWINK: + case SIG_EM: + case SIG_EM_E1: + case SIG_FEATD: + case SIG_FEATDMF: + case SIG_E911: + case SIG_FGC_CAMA: + case SIG_FGC_CAMAMF: + case SIG_FEATB: + case SIG_SFWINK: + case SIG_SF: + case SIG_SF_FEATD: + case SIG_SF_FEATDMF: + case SIG_FEATDMF_TA: + case SIG_SF_FEATB: + break; + default: + /* The rest of the function should cover the remainder of signalling types */ + return 0; + } + + if (radio) + return 0; + + if (oprmode) + return 0; + + return 1; +} + #define sig2str dahdi_sig2str static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int idx, int slavechannel) @@ -3025,53 +3974,6 @@ static int save_conference(struct dahdi_pvt *p) return 0; } -/*! - * \brief Send MWI state change - * - * \arg mailbox_full This is the mailbox associated with the FXO line that the - * MWI state has changed on. - * \arg thereornot This argument should simply be set to 1 or 0, to indicate - * whether there are messages waiting or not. - * - * \return nothing - * - * This function does two things: - * - * 1) It generates an internal Asterisk event notifying any other module that - * cares about MWI that the state of a mailbox has changed. - * - * 2) It runs the script specified by the mwimonitornotify option to allow - * some custom handling of the state change. - */ -static void notify_message(char *mailbox_full, int thereornot) -{ - char s[sizeof(mwimonitornotify) + 80]; - struct ast_event *event; - char *mailbox, *context; - - /* Strip off @default */ - context = mailbox = ast_strdupa(mailbox_full); - strsep(&context, "@"); - if (ast_strlen_zero(context)) - context = "default"; - - if (!(event = ast_event_new(AST_EVENT_MWI, - AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox, - AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context, - AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot, - AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot, - AST_EVENT_IE_END))) { - return; - } - - ast_event_queue_and_cache(event); - - if (!ast_strlen_zero(mailbox) && !ast_strlen_zero(mwimonitornotify)) { - snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot); - ast_safe_system(s); - } -} - static int restore_conference(struct dahdi_pvt *p) { int res; @@ -3129,6 +4031,8 @@ static int has_voicemail(struct dahdi_pvt *p) return new_msgs; } + + static int send_callerid(struct dahdi_pvt *p) { /* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */ @@ -3243,6 +4147,14 @@ static int dahdi_call(struct ast_channel *ast, char *rdest, int timeout) set_actual_gain(p->subs[SUB_REAL].dfd, 0, p->rxgain, p->txgain, p->law); + /* If this is analog signalling we can exit here */ + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + p->callwaitrings = 0; + res = analog_call(p->sig_pvt, ast, rdest, timeout); + ast_mutex_unlock(&p->lock); + return res; + } + mysig = p->sig; if (p->outsigmod > -1) mysig = p->outsigmod; @@ -4437,6 +5349,34 @@ static int dahdi_hangup(struct ast_channel *ast) return 0; } + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + ast_mutex_lock(&p->lock); + + dahdi_confmute(p, 0); + restore_gains(p); + p->ignoredtmf = 0; + + if (p->bufferoverrideinuse) { + /* faxbuffers are in use, revert them */ + struct dahdi_bufferinfo bi = { + .txbufpolicy = p->buf_policy, + .rxbufpolicy = p->buf_policy, + .bufsize = p->bufsize, + .numbufs = p->buf_no + }; + int bpres; + + if ((bpres = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) { + ast_log(LOG_WARNING, "Channel '%s' unable to revert buffer policy: %s\n", ast->name, strerror(errno)); + } + p->bufferoverrideinuse = 0; + } + + res = analog_hangup(p->sig_pvt, ast); + + goto hangup_out; + } + ast_mutex_lock(&p->lock); idx = dahdi_get_index(ast, p, 1); @@ -4603,9 +5543,9 @@ static int dahdi_hangup(struct ast_channel *ast) int bpres; if ((bpres = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) { - ast_log(LOG_WARNING, "Channel '%s' unable to revert faxbuffer policy: %s\n", ast->name, strerror(errno)); + ast_log(LOG_WARNING, "Channel '%s' unable to revert buffer policy: %s\n", ast->name, strerror(errno)); } - p->bufferoverrideinuse = 0; + p->bufferoverrideinuse = 0; } law = DAHDI_LAW_DEFAULT; @@ -4745,15 +5685,12 @@ static int dahdi_hangup(struct ast_channel *ast) default: tone_zone_play_tone(p->subs[SUB_REAL].dfd, -1); } - if (p->cidspill) - ast_free(p->cidspill); if (p->sig) dahdi_disable_ec(p); x = 0; ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0); ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0); p->didtdd = 0; - p->cidspill = NULL; p->callwaitcas = 0; p->callwaiting = p->permcallwaiting; p->hidecallerid = p->permhidecallerid; @@ -4789,6 +5726,11 @@ static int dahdi_hangup(struct ast_channel *ast) p->cidcwexpire = 0; p->oprmode = 0; ast->tech_pvt = NULL; +hangup_out: + if (p->cidspill) + ast_free(p->cidspill); + p->cidspill = NULL; + ast_mutex_unlock(&p->lock); ast_module_unref(ast_module_info->self); ast_verb(3, "Hungup '%s'\n", ast->name); @@ -4832,6 +5774,13 @@ static int dahdi_answer(struct ast_channel *ast) ast_mutex_unlock(&p->lock); return 0; } + + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + res = analog_answer(p->sig_pvt, ast); + ast_mutex_unlock(&p->lock); + return res; + } + switch (p->sig) { case SIG_FXSLS: case SIG_FXSGS: @@ -5666,6 +6615,11 @@ static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) } if (newchan->_state == AST_STATE_RINGING) dahdi_indicate(newchan, AST_CONTROL_RINGING, NULL, 0); + + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + analog_fixup(oldchan, newchan, p->sig_pvt); + } + update_conf(p); ast_mutex_unlock(&p->lock); return 0; @@ -5701,7 +6655,7 @@ static int dahdi_ring_phone(struct dahdi_pvt *p) return res; } -static void *ss_thread(void *data); +static void *analog_ss_thread(void *data); static int attempt_transfer(struct dahdi_pvt *p) { @@ -5848,7 +6802,7 @@ static void dahdi_handle_dtmfup(struct ast_channel *ast, int idx, struct ast_fra int res; if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) { - ast_log(LOG_WARNING, "Channel '%s' unable to set faxbuffer policy, reason: %s\n", ast->name, strerror(errno)); + ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast->name, strerror(errno)); } else { p->bufferoverrideinuse = 1; } @@ -5961,820 +6915,818 @@ static struct ast_frame *dahdi_handle_event(struct ast_channel *ast) } switch (res) { - case DAHDI_EVENT_EC_DISABLED: - ast_verb(3, "Channel %d echo canceler disabled.\n", p->channel); - p->echocanon = 0; - break; + case DAHDI_EVENT_EC_DISABLED: + ast_verb(3, "Channel %d echo canceler disabled.\n", p->channel); + p->echocanon = 0; + break; #ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE - case DAHDI_EVENT_TX_CED_DETECTED: - ast_verb(3, "Channel %d detected a CED tone towards the network.\n", p->channel); - break; - case DAHDI_EVENT_RX_CED_DETECTED: - ast_verb(3, "Channel %d detected a CED tone from the network.\n", p->channel); - break; - case DAHDI_EVENT_EC_NLP_DISABLED: - ast_verb(3, "Channel %d echo canceler disabled its NLP.\n", p->channel); - break; - case DAHDI_EVENT_EC_NLP_ENABLED: - ast_verb(3, "Channel %d echo canceler enabled its NLP.\n", p->channel); - break; + case DAHDI_EVENT_TX_CED_DETECTED: + ast_verb(3, "Channel %d detected a CED tone towards the network.\n", p->channel); + break; + case DAHDI_EVENT_RX_CED_DETECTED: + ast_verb(3, "Channel %d detected a CED tone from the network.\n", p->channel); + break; + case DAHDI_EVENT_EC_NLP_DISABLED: + ast_verb(3, "Channel %d echo canceler disabled its NLP.\n", p->channel); + break; + case DAHDI_EVENT_EC_NLP_ENABLED: + ast_verb(3, "Channel %d echo canceler enabled its NLP.\n", p->channel); + break; #endif - case DAHDI_EVENT_BITSCHANGED: + case DAHDI_EVENT_BITSCHANGED: #ifdef HAVE_OPENR2 - if (p->sig != SIG_MFCR2) { - ast_log(LOG_WARNING, "Recieved bits changed on %s signalling?\n", sig2str(p->sig)); - } else { - ast_log(LOG_DEBUG, "bits changed in chan %d\n", p->channel); - openr2_chan_handle_cas(p->r2chan); - } -#else + if (p->sig != SIG_MFCR2) { ast_log(LOG_WARNING, "Recieved bits changed on %s signalling?\n", sig2str(p->sig)); + } else { + ast_log(LOG_DEBUG, "bits changed in chan %d\n", p->channel); + openr2_chan_handle_cas(p->r2chan); + } +#else + ast_log(LOG_WARNING, "Recieved bits changed on %s signalling?\n", sig2str(p->sig)); #endif - case DAHDI_EVENT_PULSE_START: - /* Stop tone if there's a pulse start and the PBX isn't started */ - if (!ast->pbx) - tone_zone_play_tone(p->subs[idx].dfd, -1); - break; - case DAHDI_EVENT_DIALCOMPLETE: + case DAHDI_EVENT_PULSE_START: + /* Stop tone if there's a pulse start and the PBX isn't started */ + if (!ast->pbx) + tone_zone_play_tone(p->subs[idx].dfd, -1); + break; + case DAHDI_EVENT_DIALCOMPLETE: #ifdef HAVE_OPENR2 - if ((p->sig & SIG_MFCR2) && p->r2chan && ast->_state != AST_STATE_UP) { - /* we don't need to do anything for this event for R2 signaling - if the call is being setup */ - break; - } + if ((p->sig & SIG_MFCR2) && p->r2chan && ast->_state != AST_STATE_UP) { + /* we don't need to do anything for this event for R2 signaling + if the call is being setup */ + break; + } #endif - if (p->inalarm) break; - if ((p->radio || (p->oprmode < 0))) break; - if (ioctl(p->subs[idx].dfd,DAHDI_DIALING,&x) == -1) { - ast_log(LOG_DEBUG, "DAHDI_DIALING ioctl failed on %s: %s\n",ast->name, strerror(errno)); - return NULL; - } - if (!x) { /* if not still dialing in driver */ - dahdi_enable_ec(p); - if (p->echobreak) { - dahdi_train_ec(p); - ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr)); - p->dop.op = DAHDI_DIAL_OP_REPLACE; - res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); - p->echobreak = 0; - } else { - p->dialing = 0; - if ((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) { - /* if thru with dialing after offhook */ - if (ast->_state == AST_STATE_DIALING_OFFHOOK) { - ast_setstate(ast, AST_STATE_UP); - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_ANSWER; - break; - } else { /* if to state wait for offhook to dial rest */ - /* we now wait for off hook */ - ast_setstate(ast,AST_STATE_DIALING_OFFHOOK); - } + if (p->inalarm) break; + if ((p->radio || (p->oprmode < 0))) break; + if (ioctl(p->subs[idx].dfd,DAHDI_DIALING,&x) == -1) { + ast_log(LOG_DEBUG, "DAHDI_DIALING ioctl failed on %s: %s\n",ast->name, strerror(errno)); + return NULL; + } + if (!x) { /* if not still dialing in driver */ + dahdi_enable_ec(p); + if (p->echobreak) { + dahdi_train_ec(p); + ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr)); + p->dop.op = DAHDI_DIAL_OP_REPLACE; + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); + p->echobreak = 0; + } else { + p->dialing = 0; + if ((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) { + /* if thru with dialing after offhook */ + if (ast->_state == AST_STATE_DIALING_OFFHOOK) { + ast_setstate(ast, AST_STATE_UP); + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_ANSWER; + break; + } else { /* if to state wait for offhook to dial rest */ + /* we now wait for off hook */ + ast_setstate(ast,AST_STATE_DIALING_OFFHOOK); } - if (ast->_state == AST_STATE_DIALING) { - if ((p->callprogress & CALLPROGRESS_PROGRESS) && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) { - ast_debug(1, "Done dialing, but waiting for progress detection before doing more...\n"); - } else if (p->confirmanswer || (!p->dialednone - && ((mysig == SIG_EM) || (mysig == SIG_EM_E1) - || (mysig == SIG_EMWINK) || (mysig == SIG_FEATD) - || (mysig == SIG_FEATDMF_TA) || (mysig == SIG_FEATDMF) - || (mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) - || (mysig == SIG_FGC_CAMAMF) || (mysig == SIG_FEATB) - || (mysig == SIG_SF) || (mysig == SIG_SFWINK) - || (mysig == SIG_SF_FEATD) || (mysig == SIG_SF_FEATDMF) - || (mysig == SIG_SF_FEATB)))) { - ast_setstate(ast, AST_STATE_RINGING); - } else if (!p->answeronpolarityswitch) { - ast_setstate(ast, AST_STATE_UP); - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_ANSWER; - /* If aops=0 and hops=1, this is necessary */ - p->polarity = POLARITY_REV; - } else { - /* Start clean, so we can catch the change to REV polarity when party answers */ - p->polarity = POLARITY_IDLE; - } + } + if (ast->_state == AST_STATE_DIALING) { + if ((p->callprogress & CALLPROGRESS_PROGRESS) && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) { + ast_debug(1, "Done dialing, but waiting for progress detection before doing more...\n"); + } else if (p->confirmanswer || (!p->dialednone + && ((mysig == SIG_EM) || (mysig == SIG_EM_E1) + || (mysig == SIG_EMWINK) || (mysig == SIG_FEATD) + || (mysig == SIG_FEATDMF_TA) || (mysig == SIG_FEATDMF) + || (mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) + || (mysig == SIG_FGC_CAMAMF) || (mysig == SIG_FEATB) + || (mysig == SIG_SF) || (mysig == SIG_SFWINK) + || (mysig == SIG_SF_FEATD) || (mysig == SIG_SF_FEATDMF) + || (mysig == SIG_SF_FEATB)))) { + ast_setstate(ast, AST_STATE_RINGING); + } else if (!p->answeronpolarityswitch) { + ast_setstate(ast, AST_STATE_UP); + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_ANSWER; + /* If aops=0 and hops=1, this is necessary */ + p->polarity = POLARITY_REV; + } else { + /* Start clean, so we can catch the change to REV polarity when party answers */ + p->polarity = POLARITY_IDLE; } } } - break; - case DAHDI_EVENT_ALARM: + } + break; + case DAHDI_EVENT_ALARM: #ifdef HAVE_PRI - if ((p->sig == SIG_PRI) || (p->sig == SIG_BRI) || (p->sig == SIG_BRI_PTMP)) { - if (!p->pri || !p->pri->pri || (pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0)) { - /* T309 is not enabled : hangup calls when alarm occurs */ - if (p->call) { - if (p->pri && p->pri->pri) { - if (!pri_grab(p, p->pri)) { - pri_hangup(p->pri->pri, p->call, -1); - pri_destroycall(p->pri->pri, p->call); - p->call = NULL; - pri_rel(p->pri); - } else - ast_log(LOG_WARNING, "Failed to grab PRI!\n"); + if ((p->sig == SIG_PRI) || (p->sig == SIG_BRI) || (p->sig == SIG_BRI_PTMP)) { + if (!p->pri || !p->pri->pri || (pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0)) { + /* T309 is not enabled : hangup calls when alarm occurs */ + if (p->call) { + if (p->pri && p->pri->pri) { + if (!pri_grab(p, p->pri)) { + pri_hangup(p->pri->pri, p->call, -1); + pri_destroycall(p->pri->pri, p->call); + p->call = NULL; + pri_rel(p->pri); } else - ast_log(LOG_WARNING, "The PRI Call has not been destroyed\n"); - } - if (p->owner) - p->owner->_softhangup |= AST_SOFTHANGUP_DEV; + ast_log(LOG_WARNING, "Failed to grab PRI!\n"); + } else + ast_log(LOG_WARNING, "The PRI Call has not been destroyed\n"); } + if (p->owner) + p->owner->_softhangup |= AST_SOFTHANGUP_DEV; } - if (p->bearer) - p->bearer->inalarm = 1; - else + } + if (p->bearer) + p->bearer->inalarm = 1; + else #endif - p->inalarm = 1; - res = get_alarms(p); - handle_alarms(p, res); + p->inalarm = 1; + res = get_alarms(p); + handle_alarms(p, res); #ifdef HAVE_PRI - if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) { - /* fall through intentionally */ - } else { - break; - } + if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) { + /* fall through intentionally */ + } else { + break; + } #endif #ifdef HAVE_SS7 - if (p->sig == SIG_SS7) - break; + if (p->sig == SIG_SS7) + break; #endif #ifdef HAVE_OPENR2 - if (p->sig == SIG_MFCR2) - break; + if (p->sig == SIG_MFCR2) + break; #endif - case DAHDI_EVENT_ONHOOK: - if (p->radio) { - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_RADIO_UNKEY; - break; - } - if (p->oprmode < 0) + case DAHDI_EVENT_ONHOOK: + if (p->radio) { + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_RADIO_UNKEY; + break; + } + if (p->oprmode < 0) + { + if (p->oprmode != -1) break; + if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS)) { - if (p->oprmode != -1) break; - if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS)) - { - /* Make sure it starts ringing */ - dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF); - dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RING); - save_conference(p->oprpeer); - tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); - } - break; + /* Make sure it starts ringing */ + dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF); + dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RING); + save_conference(p->oprpeer); + tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); } - switch (p->sig) { - case SIG_FXOLS: - case SIG_FXOGS: - case SIG_FXOKS: - p->onhooktime = time(NULL); - p->fxsoffhookstate = 0; - p->msgstate = -1; - /* Check for some special conditions regarding call waiting */ - if (idx == SUB_REAL) { - /* The normal line was hung up */ - if (p->subs[SUB_CALLWAIT].owner) { - /* There's a call waiting call, so ring the phone, but make it unowned in the mean time */ - swap_subs(p, SUB_CALLWAIT, SUB_REAL); - ast_verb(3, "Channel %d still has (callwait) call, ringing phone\n", p->channel); - unalloc_sub(p, SUB_CALLWAIT); + break; + } + switch (p->sig) { + case SIG_FXOLS: + case SIG_FXOGS: + case SIG_FXOKS: + p->onhooktime = time(NULL); + p->fxsoffhookstate = 0; + p->msgstate = -1; + /* Check for some special conditions regarding call waiting */ + if (idx == SUB_REAL) { + /* The normal line was hung up */ + if (p->subs[SUB_CALLWAIT].owner) { + /* There's a call waiting call, so ring the phone, but make it unowned in the mean time */ + swap_subs(p, SUB_CALLWAIT, SUB_REAL); + ast_verb(3, "Channel %d still has (callwait) call, ringing phone\n", p->channel); + unalloc_sub(p, SUB_CALLWAIT); #if 0 - p->subs[idx].needanswer = 0; - p->subs[idx].needringing = 0; + p->subs[idx].needanswer = 0; + p->subs[idx].needringing = 0; #endif - p->callwaitingrepeat = 0; - p->cidcwexpire = 0; - p->owner = NULL; - /* Don't start streaming audio yet if the incoming call isn't up yet */ - if (p->subs[SUB_REAL].owner->_state != AST_STATE_UP) - p->dialing = 1; - dahdi_ring_phone(p); - } else if (p->subs[SUB_THREEWAY].owner) { - unsigned int mssinceflash; - /* Here we have to retain the lock on both the main channel, the 3-way channel, and - the private structure -- not especially easy or clean */ - while (p->subs[SUB_THREEWAY].owner && ast_channel_trylock(p->subs[SUB_THREEWAY].owner)) { - /* Yuck, didn't get the lock on the 3-way, gotta release everything and re-grab! */ - DLA_UNLOCK(&p->lock); - CHANNEL_DEADLOCK_AVOIDANCE(ast); - /* We can grab ast and p in that order, without worry. We should make sure - nothing seriously bad has happened though like some sort of bizarre double - masquerade! */ - DLA_LOCK(&p->lock); - if (p->owner != ast) { - ast_log(LOG_WARNING, "This isn't good...\n"); - return NULL; - } - } - if (!p->subs[SUB_THREEWAY].owner) { - ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n"); + p->callwaitingrepeat = 0; + p->cidcwexpire = 0; + p->owner = NULL; + /* Don't start streaming audio yet if the incoming call isn't up yet */ + if (p->subs[SUB_REAL].owner->_state != AST_STATE_UP) + p->dialing = 1; + dahdi_ring_phone(p); + } else if (p->subs[SUB_THREEWAY].owner) { + unsigned int mssinceflash; + /* Here we have to retain the lock on both the main channel, the 3-way channel, and + the private structure -- not especially easy or clean */ + while (p->subs[SUB_THREEWAY].owner && ast_channel_trylock(p->subs[SUB_THREEWAY].owner)) { + /* Yuck, didn't get the lock on the 3-way, gotta release everything and re-grab! */ + DLA_UNLOCK(&p->lock); + CHANNEL_DEADLOCK_AVOIDANCE(ast); + /* We can grab ast and p in that order, without worry. We should make sure + nothing seriously bad has happened though like some sort of bizarre double + masquerade! */ + DLA_LOCK(&p->lock); + if (p->owner != ast) { + ast_log(LOG_WARNING, "This isn't good...\n"); return NULL; } - mssinceflash = ast_tvdiff_ms(ast_tvnow(), p->flashtime); - ast_debug(1, "Last flash was %d ms ago\n", mssinceflash); - if (mssinceflash < MIN_MS_SINCE_FLASH) { - /* It hasn't been long enough since the last flashook. This is probably a bounce on - hanging up. Hangup both channels now */ - if (p->subs[SUB_THREEWAY].owner) - ast_queue_hangup_with_cause(p->subs[SUB_THREEWAY].owner, AST_CAUSE_NO_ANSWER); - p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; - ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel); - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); - } else if ((ast->pbx) || (ast->_state == AST_STATE_UP)) { - if (p->transfer) { - /* In any case this isn't a threeway call anymore */ - p->subs[SUB_REAL].inthreeway = 0; - p->subs[SUB_THREEWAY].inthreeway = 0; - /* Only attempt transfer if the phone is ringing; why transfer to busy tone eh? */ - if (!p->transfertobusy && ast->_state == AST_STATE_BUSY) { - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); - /* Swap subs and dis-own channel */ - swap_subs(p, SUB_THREEWAY, SUB_REAL); - p->owner = NULL; - /* Ring the phone */ - dahdi_ring_phone(p); - } else { - if ((res = attempt_transfer(p)) < 0) { - p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; - if (p->subs[SUB_THREEWAY].owner) - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); - } else if (res) { - /* Don't actually hang up at this point */ - if (p->subs[SUB_THREEWAY].owner) - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); - break; - } - } + } + if (!p->subs[SUB_THREEWAY].owner) { + ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n"); + return NULL; + } + mssinceflash = ast_tvdiff_ms(ast_tvnow(), p->flashtime); + ast_debug(1, "Last flash was %d ms ago\n", mssinceflash); + if (mssinceflash < MIN_MS_SINCE_FLASH) { + /* It hasn't been long enough since the last flashook. This is probably a bounce on + hanging up. Hangup both channels now */ + if (p->subs[SUB_THREEWAY].owner) + ast_queue_hangup_with_cause(p->subs[SUB_THREEWAY].owner, AST_CAUSE_NO_ANSWER); + p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; + ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel); + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + } else if ((ast->pbx) || (ast->_state == AST_STATE_UP)) { + if (p->transfer) { + /* In any case this isn't a threeway call anymore */ + p->subs[SUB_REAL].inthreeway = 0; + p->subs[SUB_THREEWAY].inthreeway = 0; + /* Only attempt transfer if the phone is ringing; why transfer to busy tone eh? */ + if (!p->transfertobusy && ast->_state == AST_STATE_BUSY) { + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + /* Swap subs and dis-own channel */ + swap_subs(p, SUB_THREEWAY, SUB_REAL); + p->owner = NULL; + /* Ring the phone */ + dahdi_ring_phone(p); } else { - p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; - if (p->subs[SUB_THREEWAY].owner) - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + if ((res = attempt_transfer(p)) < 0) { + p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; + if (p->subs[SUB_THREEWAY].owner) + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + } else if (res) { + /* Don't actually hang up at this point */ + if (p->subs[SUB_THREEWAY].owner) + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + break; + } } } else { - ast_channel_unlock(p->subs[SUB_THREEWAY].owner); - /* Swap subs and dis-own channel */ - swap_subs(p, SUB_THREEWAY, SUB_REAL); - p->owner = NULL; - /* Ring the phone */ - dahdi_ring_phone(p); + p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; + if (p->subs[SUB_THREEWAY].owner) + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); } + } else { + ast_channel_unlock(p->subs[SUB_THREEWAY].owner); + /* Swap subs and dis-own channel */ + swap_subs(p, SUB_THREEWAY, SUB_REAL); + p->owner = NULL; + /* Ring the phone */ + dahdi_ring_phone(p); } - } else { - ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", idx); } - /* Fall through */ - default: - dahdi_disable_ec(p); - return NULL; + } else { + ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", idx); } - break; - case DAHDI_EVENT_RINGOFFHOOK: - if (p->inalarm) break; - if (p->oprmode < 0) + /* Fall through */ + default: + dahdi_disable_ec(p); + return NULL; + } + break; + case DAHDI_EVENT_RINGOFFHOOK: + if (p->inalarm) break; + if (p->oprmode < 0) + { + if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS)) { - if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS)) - { - /* Make sure it stops ringing */ - dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF); - tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, -1); - restore_conference(p->oprpeer); - } - break; + /* Make sure it stops ringing */ + dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF); + tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, -1); + restore_conference(p->oprpeer); } - if (p->radio) - { - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_RADIO_KEY; - break; - } - /* for E911, its supposed to wait for offhook then dial - the second half of the dial string */ - if (((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) && (ast->_state == AST_STATE_DIALING_OFFHOOK)) { - c = strchr(p->dialdest, '/'); - if (c) - c++; - else - c = p->dialdest; - if (*c) snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*0%s#", c); - else ast_copy_string(p->dop.dialstr,"M*2#", sizeof(p->dop.dialstr)); - if (strlen(p->dop.dialstr) > 4) { - memset(p->echorest, 'w', sizeof(p->echorest) - 1); - strcpy(p->echorest + (p->echotraining / 401) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2); - p->echorest[sizeof(p->echorest) - 1] = '\0'; - p->echobreak = 1; - p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0'; - } else - p->echobreak = 0; - if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop)) { - int saveerr = errno; + break; + } + if (p->radio) + { + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_RADIO_KEY; + break; + } + /* for E911, its supposed to wait for offhook then dial + the second half of the dial string */ + if (((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) && (ast->_state == AST_STATE_DIALING_OFFHOOK)) { + c = strchr(p->dialdest, '/'); + if (c) + c++; + else + c = p->dialdest; + if (*c) snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*0%s#", c); + else ast_copy_string(p->dop.dialstr,"M*2#", sizeof(p->dop.dialstr)); + if (strlen(p->dop.dialstr) > 4) { + memset(p->echorest, 'w', sizeof(p->echorest) - 1); + strcpy(p->echorest + (p->echotraining / 401) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2); + p->echorest[sizeof(p->echorest) - 1] = '\0'; + p->echobreak = 1; + p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0'; + } else + p->echobreak = 0; + if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop)) { + int saveerr = errno; - x = DAHDI_ONHOOK; - ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); - ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr)); - return NULL; - } - p->dialing = 1; - return &p->subs[idx].f; - } - switch (p->sig) { - case SIG_FXOLS: - case SIG_FXOGS: - case SIG_FXOKS: - p->fxsoffhookstate = 1; - switch (ast->_state) { - case AST_STATE_RINGING: - dahdi_enable_ec(p); - dahdi_train_ec(p); - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_ANSWER; - /* Make sure it stops ringing */ - dahdi_set_hook(p->subs[idx].dfd, DAHDI_OFFHOOK); - ast_debug(1, "channel %d answered\n", p->channel); - if (p->cidspill) { - /* Cancel any running CallerID spill */ - ast_free(p->cidspill); - p->cidspill = NULL; - } - p->dialing = 0; - p->callwaitcas = 0; - if (p->confirmanswer) { - /* Ignore answer if "confirm answer" is enabled */ - p->subs[idx].f.frametype = AST_FRAME_NULL; - p->subs[idx].f.subclass = 0; - } else if (!ast_strlen_zero(p->dop.dialstr)) { - /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */ - res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); - if (res < 0) { - ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); - p->dop.dialstr[0] = '\0'; - return NULL; - } else { - ast_debug(1, "Sent FXO deferred digit string: %s\n", p->dop.dialstr); - p->subs[idx].f.frametype = AST_FRAME_NULL; - p->subs[idx].f.subclass = 0; - p->dialing = 1; - } - p->dop.dialstr[0] = '\0'; - ast_setstate(ast, AST_STATE_DIALING); - } else - ast_setstate(ast, AST_STATE_UP); - return &p->subs[idx].f; - case AST_STATE_DOWN: - ast_setstate(ast, AST_STATE_RING); - ast->rings = 1; - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_OFFHOOK; - ast_debug(1, "channel %d picked up\n", p->channel); - return &p->subs[idx].f; - case AST_STATE_UP: - /* Make sure it stops ringing */ - dahdi_set_hook(p->subs[idx].dfd, DAHDI_OFFHOOK); - /* Okay -- probably call waiting*/ - if (ast_bridged_channel(p->owner)) - ast_queue_control(p->owner, AST_CONTROL_UNHOLD); - p->subs[idx].needunhold = 1; - break; - case AST_STATE_RESERVED: - /* Start up dialtone */ - if (has_voicemail(p)) - res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_STUTTER); - else - res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_DIALTONE); - break; - default: - ast_log(LOG_WARNING, "FXO phone off hook in weird state %d??\n", ast->_state); + x = DAHDI_ONHOOK; + ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); + ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr)); + return NULL; } - break; - case SIG_FXSLS: - case SIG_FXSGS: - case SIG_FXSKS: - if (ast->_state == AST_STATE_RING) { - p->ringt = p->ringt_base; + p->dialing = 1; + return &p->subs[idx].f; + } + switch (p->sig) { + case SIG_FXOLS: + case SIG_FXOGS: + case SIG_FXOKS: + p->fxsoffhookstate = 1; + switch (ast->_state) { + case AST_STATE_RINGING: + dahdi_enable_ec(p); + dahdi_train_ec(p); + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_ANSWER; + /* Make sure it stops ringing */ + dahdi_set_hook(p->subs[idx].dfd, DAHDI_OFFHOOK); + ast_debug(1, "channel %d answered\n", p->channel); + if (p->cidspill) { + /* Cancel any running CallerID spill */ + ast_free(p->cidspill); + p->cidspill = NULL; } - - /* If we get a ring then we cannot be in - * reversed polarity. So we reset to idle */ - ast_debug(1, "Setting IDLE polarity due " - "to ring. Old polarity was %d\n", - p->polarity); - p->polarity = POLARITY_IDLE; - - /* Fall through */ - case SIG_EM: - case SIG_EM_E1: - case SIG_EMWINK: - case SIG_FEATD: - case SIG_FEATDMF: - case SIG_FEATDMF_TA: - case SIG_E911: - case SIG_FGC_CAMA: - case SIG_FGC_CAMAMF: - case SIG_FEATB: - case SIG_SF: - case SIG_SFWINK: - case SIG_SF_FEATD: - case SIG_SF_FEATDMF: - case SIG_SF_FEATB: - if (ast->_state == AST_STATE_PRERING) - ast_setstate(ast, AST_STATE_RING); - if ((ast->_state == AST_STATE_DOWN) || (ast->_state == AST_STATE_RING)) { - ast_debug(1, "Ring detected\n"); - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_RING; - } else if (p->outgoing && ((ast->_state == AST_STATE_RINGING) || (ast->_state == AST_STATE_DIALING))) { - ast_debug(1, "Line answered\n"); - if (p->confirmanswer) { + p->dialing = 0; + p->callwaitcas = 0; + if (p->confirmanswer) { + /* Ignore answer if "confirm answer" is enabled */ + p->subs[idx].f.frametype = AST_FRAME_NULL; + p->subs[idx].f.subclass = 0; + } else if (!ast_strlen_zero(p->dop.dialstr)) { + /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */ + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; + } else { + ast_debug(1, "Sent FXO deferred digit string: %s\n", p->dop.dialstr); p->subs[idx].f.frametype = AST_FRAME_NULL; p->subs[idx].f.subclass = 0; - } else { - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_ANSWER; - ast_setstate(ast, AST_STATE_UP); + p->dialing = 1; } - } else if (ast->_state != AST_STATE_RING) - ast_log(LOG_WARNING, "Ring/Off-hook in strange state %d on channel %d\n", ast->_state, p->channel); + p->dop.dialstr[0] = '\0'; + ast_setstate(ast, AST_STATE_DIALING); + } else + ast_setstate(ast, AST_STATE_UP); + return &p->subs[idx].f; + case AST_STATE_DOWN: + ast_setstate(ast, AST_STATE_RING); + ast->rings = 1; + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_OFFHOOK; + ast_debug(1, "channel %d picked up\n", p->channel); + return &p->subs[idx].f; + case AST_STATE_UP: + /* Make sure it stops ringing */ + dahdi_set_hook(p->subs[idx].dfd, DAHDI_OFFHOOK); + /* Okay -- probably call waiting*/ + if (ast_bridged_channel(p->owner)) + ast_queue_control(p->owner, AST_CONTROL_UNHOLD); + p->subs[idx].needunhold = 1; + break; + case AST_STATE_RESERVED: + /* Start up dialtone */ + if (has_voicemail(p)) + res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_STUTTER); + else + res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_DIALTONE); break; default: - ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig); + ast_log(LOG_WARNING, "FXO phone off hook in weird state %d??\n", ast->_state); } break; - case DAHDI_EVENT_RINGBEGIN: - switch (p->sig) { - case SIG_FXSLS: - case SIG_FXSGS: - case SIG_FXSKS: - if (ast->_state == AST_STATE_RING) { - p->ringt = p->ringt_base; - } - break; + case SIG_FXSLS: + case SIG_FXSGS: + case SIG_FXSKS: + if (ast->_state == AST_STATE_RING) { + p->ringt = p->ringt_base; } + + /* If we get a ring then we cannot be in + * reversed polarity. So we reset to idle */ + ast_debug(1, "Setting IDLE polarity due " + "to ring. Old polarity was %d\n", + p->polarity); + p->polarity = POLARITY_IDLE; + + /* Fall through */ + case SIG_EM: + case SIG_EM_E1: + case SIG_EMWINK: + case SIG_FEATD: + case SIG_FEATDMF: + case SIG_FEATDMF_TA: + case SIG_E911: + case SIG_FGC_CAMA: + case SIG_FGC_CAMAMF: + case SIG_FEATB: + case SIG_SF: + case SIG_SFWINK: + case SIG_SF_FEATD: + case SIG_SF_FEATDMF: + case SIG_SF_FEATB: + if (ast->_state == AST_STATE_PRERING) + ast_setstate(ast, AST_STATE_RING); + if ((ast->_state == AST_STATE_DOWN) || (ast->_state == AST_STATE_RING)) { + ast_debug(1, "Ring detected\n"); + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_RING; + } else if (p->outgoing && ((ast->_state == AST_STATE_RINGING) || (ast->_state == AST_STATE_DIALING))) { + ast_debug(1, "Line answered\n"); + if (p->confirmanswer) { + p->subs[idx].f.frametype = AST_FRAME_NULL; + p->subs[idx].f.subclass = 0; + } else { + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_ANSWER; + ast_setstate(ast, AST_STATE_UP); + } + } else if (ast->_state != AST_STATE_RING) + ast_log(LOG_WARNING, "Ring/Off-hook in strange state %d on channel %d\n", ast->_state, p->channel); break; - case DAHDI_EVENT_RINGEROFF: - if (p->inalarm) break; - if ((p->radio || (p->oprmode < 0))) break; - ast->rings++; - if ((ast->rings > p->cidrings) && (p->cidspill)) { - ast_log(LOG_WARNING, "Didn't finish Caller-ID spill. Cancelling.\n"); - ast_free(p->cidspill); - p->cidspill = NULL; - p->callwaitcas = 0; + default: + ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig); + } + break; + case DAHDI_EVENT_RINGBEGIN: + switch (p->sig) { + case SIG_FXSLS: + case SIG_FXSGS: + case SIG_FXSKS: + if (ast->_state == AST_STATE_RING) { + p->ringt = p->ringt_base; } - p->subs[idx].f.frametype = AST_FRAME_CONTROL; - p->subs[idx].f.subclass = AST_CONTROL_RINGING; - break; - case DAHDI_EVENT_RINGERON: break; - case DAHDI_EVENT_NOALARM: - p->inalarm = 0; + } + break; + case DAHDI_EVENT_RINGEROFF: + if (p->inalarm) break; + if ((p->radio || (p->oprmode < 0))) break; + ast->rings++; + if ((ast->rings > p->cidrings) && (p->cidspill)) { + ast_log(LOG_WARNING, "Didn't finish Caller-ID spill. Cancelling.\n"); + ast_free(p->cidspill); + p->cidspill = NULL; + p->callwaitcas = 0; + } + p->subs[idx].f.frametype = AST_FRAME_CONTROL; + p->subs[idx].f.subclass = AST_CONTROL_RINGING; + break; + case DAHDI_EVENT_RINGERON: + break; + case DAHDI_EVENT_NOALARM: + p->inalarm = 0; #ifdef HAVE_PRI - /* Extremely unlikely but just in case */ - if (p->bearer) - p->bearer->inalarm = 0; + /* Extremely unlikely but just in case */ + if (p->bearer) + p->bearer->inalarm = 0; #endif - ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel); - manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", - "Channel: %d\r\n", p->channel); - break; - case DAHDI_EVENT_WINKFLASH: - if (p->inalarm) break; - if (p->radio) break; - if (p->oprmode < 0) break; - if (p->oprmode > 1) - { - struct dahdi_params par; + ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel); + manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", + "Channel: %d\r\n", p->channel); + break; + case DAHDI_EVENT_WINKFLASH: + if (p->inalarm) break; + if (p->radio) break; + if (p->oprmode < 0) break; + if (p->oprmode > 1) + { + struct dahdi_params par; - memset(&par, 0, sizeof(par)); - if (ioctl(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par) != -1) + memset(&par, 0, sizeof(par)); + if (ioctl(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par) != -1) + { + if (!par.rxisoffhook) { - if (!par.rxisoffhook) - { - /* Make sure it stops ringing */ - dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RINGOFF); - dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RING); - save_conference(p); - tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); - } + /* Make sure it stops ringing */ + dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RINGOFF); + dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RING); + save_conference(p); + tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); } - break; } - /* Remember last time we got a flash-hook */ - p->flashtime = ast_tvnow(); - switch (mysig) { - case SIG_FXOLS: - case SIG_FXOGS: - case SIG_FXOKS: - ast_debug(1, "Winkflash, index: %d, normal: %d, callwait: %d, thirdcall: %d\n", - idx, p->subs[SUB_REAL].dfd, p->subs[SUB_CALLWAIT].dfd, p->subs[SUB_THREEWAY].dfd); - p->callwaitcas = 0; + break; + } + /* Remember last time we got a flash-hook */ + p->flashtime = ast_tvnow(); + switch (mysig) { + case SIG_FXOLS: + case SIG_FXOGS: + case SIG_FXOKS: + ast_debug(1, "Winkflash, index: %d, normal: %d, callwait: %d, thirdcall: %d\n", + idx, p->subs[SUB_REAL].dfd, p->subs[SUB_CALLWAIT].dfd, p->subs[SUB_THREEWAY].dfd); + p->callwaitcas = 0; - if (idx != SUB_REAL) { - ast_log(LOG_WARNING, "Got flash hook with index %d on channel %d?!?\n", idx, p->channel); - goto winkflashdone; - } + if (idx != SUB_REAL) { + ast_log(LOG_WARNING, "Got flash hook with index %d on channel %d?!?\n", idx, p->channel); + goto winkflashdone; + } - if (p->subs[SUB_CALLWAIT].owner) { - /* Swap to call-wait */ - swap_subs(p, SUB_REAL, SUB_CALLWAIT); - tone_zone_play_tone(p->subs[SUB_REAL].dfd, -1); - p->owner = p->subs[SUB_REAL].owner; - ast_debug(1, "Making %s the new owner\n", p->owner->name); - if (p->owner->_state == AST_STATE_RINGING) { - ast_setstate(p->owner, AST_STATE_UP); - p->subs[SUB_REAL].needanswer = 1; - } - p->callwaitingrepeat = 0; - p->cidcwexpire = 0; - /* Start music on hold if appropriate */ - if (!p->subs[SUB_CALLWAIT].inthreeway && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) { - ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD, - S_OR(p->mohsuggest, NULL), - !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + if (p->subs[SUB_CALLWAIT].owner) { + /* Swap to call-wait */ + swap_subs(p, SUB_REAL, SUB_CALLWAIT); + tone_zone_play_tone(p->subs[SUB_REAL].dfd, -1); + p->owner = p->subs[SUB_REAL].owner; + ast_debug(1, "Making %s the new owner\n", p->owner->name); + if (p->owner->_state == AST_STATE_RINGING) { + ast_setstate(p->owner, AST_STATE_UP); + p->subs[SUB_REAL].needanswer = 1; + } + p->callwaitingrepeat = 0; + p->cidcwexpire = 0; + /* Start music on hold if appropriate */ + if (!p->subs[SUB_CALLWAIT].inthreeway && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) { + ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + p->subs[SUB_CALLWAIT].needhold = 1; + if (ast_bridged_channel(p->subs[SUB_REAL].owner)) { + ast_queue_control_data(p->subs[SUB_REAL].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + p->subs[SUB_REAL].needunhold = 1; + } else if (!p->subs[SUB_THREEWAY].owner) { + if (!p->threewaycalling) { + /* Just send a flash if no 3-way calling */ + p->subs[SUB_REAL].needflash = 1; + goto winkflashdone; + } else if (!check_for_conference(p)) { + char cid_num[256]; + char cid_name[256]; + + cid_num[0] = 0; + cid_name[0] = 0; + if (p->dahditrcallerid && p->owner) { + if (p->owner->cid.cid_num) + ast_copy_string(cid_num, p->owner->cid.cid_num, sizeof(cid_num)); + if (p->owner->cid.cid_name) + ast_copy_string(cid_name, p->owner->cid.cid_name, sizeof(cid_name)); } - p->subs[SUB_CALLWAIT].needhold = 1; - if (ast_bridged_channel(p->subs[SUB_REAL].owner)) { - ast_queue_control_data(p->subs[SUB_REAL].owner, AST_CONTROL_HOLD, - S_OR(p->mohsuggest, NULL), - !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + /* XXX This section needs much more error checking!!! XXX */ + /* Start a 3-way call if feasible */ + if (!((ast->pbx) || + (ast->_state == AST_STATE_UP) || + (ast->_state == AST_STATE_RING))) { + ast_debug(1, "Flash when call not up or ringing\n"); + goto winkflashdone; } - p->subs[SUB_REAL].needunhold = 1; - } else if (!p->subs[SUB_THREEWAY].owner) { - if (!p->threewaycalling) { - /* Just send a flash if no 3-way calling */ - p->subs[SUB_REAL].needflash = 1; + if (alloc_sub(p, SUB_THREEWAY)) { + ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n"); goto winkflashdone; - } else if (!check_for_conference(p)) { - char cid_num[256]; - char cid_name[256]; - - cid_num[0] = 0; - cid_name[0] = 0; - if (p->dahditrcallerid && p->owner) { - if (p->owner->cid.cid_num) - ast_copy_string(cid_num, p->owner->cid.cid_num, sizeof(cid_num)); - if (p->owner->cid.cid_name) - ast_copy_string(cid_name, p->owner->cid.cid_name, sizeof(cid_name)); - } - /* XXX This section needs much more error checking!!! XXX */ - /* Start a 3-way call if feasible */ - if (!((ast->pbx) || - (ast->_state == AST_STATE_UP) || - (ast->_state == AST_STATE_RING))) { - ast_debug(1, "Flash when call not up or ringing\n"); - goto winkflashdone; - } - if (alloc_sub(p, SUB_THREEWAY)) { - ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n"); - goto winkflashdone; - } - /* Make new channel */ - chan = dahdi_new(p, AST_STATE_RESERVED, 0, SUB_THREEWAY, 0, 0); - if (p->dahditrcallerid) { - if (!p->origcid_num) - p->origcid_num = ast_strdup(p->cid_num); - if (!p->origcid_name) - p->origcid_name = ast_strdup(p->cid_name); - ast_copy_string(p->cid_num, cid_num, sizeof(p->cid_num)); - ast_copy_string(p->cid_name, cid_name, sizeof(p->cid_name)); - } - /* Swap things around between the three-way and real call */ - swap_subs(p, SUB_THREEWAY, SUB_REAL); - /* Disable echo canceller for better dialing */ - dahdi_disable_ec(p); - res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_DIALRECALL); - if (res) - ast_log(LOG_WARNING, "Unable to start dial recall tone on channel %d\n", p->channel); - p->owner = chan; - if (!chan) { - ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", p->channel); - } else if (ast_pthread_create_detached(&threadid, NULL, ss_thread, chan)) { - ast_log(LOG_WARNING, "Unable to start simple switch on channel %d\n", p->channel); - res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION); - dahdi_enable_ec(p); - ast_hangup(chan); - } else { - struct ast_channel *other = ast_bridged_channel(p->subs[SUB_THREEWAY].owner); - int way3bridge = 0, cdr3way = 0; + } + /* Make new channel */ + chan = dahdi_new(p, AST_STATE_RESERVED, 0, SUB_THREEWAY, 0, 0); + if (p->dahditrcallerid) { + if (!p->origcid_num) + p->origcid_num = ast_strdup(p->cid_num); + if (!p->origcid_name) + p->origcid_name = ast_strdup(p->cid_name); + ast_copy_string(p->cid_num, cid_num, sizeof(p->cid_num)); + ast_copy_string(p->cid_name, cid_name, sizeof(p->cid_name)); + } + /* Swap things around between the three-way and real call */ + swap_subs(p, SUB_THREEWAY, SUB_REAL); + /* Disable echo canceller for better dialing */ + dahdi_disable_ec(p); + res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_DIALRECALL); + if (res) + ast_log(LOG_WARNING, "Unable to start dial recall tone on channel %d\n", p->channel); + p->owner = chan; + if (!chan) { + ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", p->channel); + } else if (ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, chan)) { + ast_log(LOG_WARNING, "Unable to start simple switch on channel %d\n", p->channel); + res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION); + dahdi_enable_ec(p); + ast_hangup(chan); + } else { + struct ast_channel *other = ast_bridged_channel(p->subs[SUB_THREEWAY].owner); + int way3bridge = 0, cdr3way = 0; - if (!other) { - other = ast_bridged_channel(p->subs[SUB_REAL].owner); - } else - way3bridge = 1; + if (!other) { + other = ast_bridged_channel(p->subs[SUB_REAL].owner); + } else + way3bridge = 1; - if (p->subs[SUB_THREEWAY].owner->cdr) - cdr3way = 1; + if (p->subs[SUB_THREEWAY].owner->cdr) + cdr3way = 1; - ast_verb(3, "Started three way call on channel %d\n", p->channel); + ast_verb(3, "Started three way call on channel %d\n", p->channel); - /* Start music on hold if appropriate */ - if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) { - ast_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD, - S_OR(p->mohsuggest, NULL), - !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); - } - p->subs[SUB_THREEWAY].needhold = 1; + /* Start music on hold if appropriate */ + if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) { + ast_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); } + p->subs[SUB_THREEWAY].needhold = 1; + } + } + } else { + /* Already have a 3 way call */ + if (p->subs[SUB_THREEWAY].inthreeway) { + /* Call is already up, drop the last person */ + ast_debug(1, "Got flash with three way call up, dropping last call on %d\n", p->channel); + /* If the primary call isn't answered yet, use it */ + if ((p->subs[SUB_REAL].owner->_state != AST_STATE_UP) && (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_UP)) { + /* Swap back -- we're dropping the real 3-way that isn't finished yet*/ + swap_subs(p, SUB_THREEWAY, SUB_REAL); + p->owner = p->subs[SUB_REAL].owner; } + /* Drop the last call and stop the conference */ + ast_verb(3, "Dropping three-way call on %s\n", p->subs[SUB_THREEWAY].owner->name); + p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; + p->subs[SUB_REAL].inthreeway = 0; + p->subs[SUB_THREEWAY].inthreeway = 0; } else { - /* Already have a 3 way call */ - if (p->subs[SUB_THREEWAY].inthreeway) { - /* Call is already up, drop the last person */ - ast_debug(1, "Got flash with three way call up, dropping last call on %d\n", p->channel); - /* If the primary call isn't answered yet, use it */ - if ((p->subs[SUB_REAL].owner->_state != AST_STATE_UP) && (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_UP)) { - /* Swap back -- we're dropping the real 3-way that isn't finished yet*/ - swap_subs(p, SUB_THREEWAY, SUB_REAL); - p->owner = p->subs[SUB_REAL].owner; - } - /* Drop the last call and stop the conference */ - ast_verb(3, "Dropping three-way call on %s\n", p->subs[SUB_THREEWAY].owner->name); - p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; - p->subs[SUB_REAL].inthreeway = 0; - p->subs[SUB_THREEWAY].inthreeway = 0; - } else { - /* Lets see what we're up to */ - if (((ast->pbx) || (ast->_state == AST_STATE_UP)) && - (p->transfertobusy || (ast->_state != AST_STATE_BUSY))) { - int otherindex = SUB_THREEWAY; - struct ast_channel *other = ast_bridged_channel(p->subs[SUB_THREEWAY].owner); - int way3bridge = 0, cdr3way = 0; - - if (!other) { - other = ast_bridged_channel(p->subs[SUB_REAL].owner); - } else - way3bridge = 1; + /* Lets see what we're up to */ + if (((ast->pbx) || (ast->_state == AST_STATE_UP)) && + (p->transfertobusy || (ast->_state != AST_STATE_BUSY))) { + int otherindex = SUB_THREEWAY; + struct ast_channel *other = ast_bridged_channel(p->subs[SUB_THREEWAY].owner); + int way3bridge = 0, cdr3way = 0; + + if (!other) { + other = ast_bridged_channel(p->subs[SUB_REAL].owner); + } else + way3bridge = 1; - if (p->subs[SUB_THREEWAY].owner->cdr) - cdr3way = 1; + if (p->subs[SUB_THREEWAY].owner->cdr) + cdr3way = 1; - ast_verb(3, "Building conference on call on %s and %s\n", p->subs[SUB_THREEWAY].owner->name, p->subs[SUB_REAL].owner->name); - /* Put them in the threeway, and flip */ - p->subs[SUB_THREEWAY].inthreeway = 1; - p->subs[SUB_REAL].inthreeway = 1; - if (ast->_state == AST_STATE_UP) { - swap_subs(p, SUB_THREEWAY, SUB_REAL); - otherindex = SUB_REAL; - } - if (p->subs[otherindex].owner && ast_bridged_channel(p->subs[otherindex].owner)) - ast_queue_control(p->subs[otherindex].owner, AST_CONTROL_UNHOLD); - p->subs[otherindex].needunhold = 1; - p->owner = p->subs[SUB_REAL].owner; - if (ast->_state == AST_STATE_RINGING) { - ast_debug(1, "Enabling ringtone on real and threeway\n"); - res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); - res = tone_zone_play_tone(p->subs[SUB_THREEWAY].dfd, DAHDI_TONE_RINGTONE); - } - } else { - ast_verb(3, "Dumping incomplete call on on %s\n", p->subs[SUB_THREEWAY].owner->name); + ast_verb(3, "Building conference on call on %s and %s\n", p->subs[SUB_THREEWAY].owner->name, p->subs[SUB_REAL].owner->name); + /* Put them in the threeway, and flip */ + p->subs[SUB_THREEWAY].inthreeway = 1; + p->subs[SUB_REAL].inthreeway = 1; + if (ast->_state == AST_STATE_UP) { swap_subs(p, SUB_THREEWAY, SUB_REAL); - p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; - p->owner = p->subs[SUB_REAL].owner; - if (p->subs[SUB_REAL].owner && ast_bridged_channel(p->subs[SUB_REAL].owner)) - ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD); - p->subs[SUB_REAL].needunhold = 1; - dahdi_enable_ec(p); + otherindex = SUB_REAL; } + if (p->subs[otherindex].owner && ast_bridged_channel(p->subs[otherindex].owner)) + ast_queue_control(p->subs[otherindex].owner, AST_CONTROL_UNHOLD); + p->subs[otherindex].needunhold = 1; + p->owner = p->subs[SUB_REAL].owner; + if (ast->_state == AST_STATE_RINGING) { + ast_debug(1, "Enabling ringtone on real and threeway\n"); + res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE); + res = tone_zone_play_tone(p->subs[SUB_THREEWAY].dfd, DAHDI_TONE_RINGTONE); + } + } else { + ast_verb(3, "Dumping incomplete call on on %s\n", p->subs[SUB_THREEWAY].owner->name); + swap_subs(p, SUB_THREEWAY, SUB_REAL); + p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV; + p->owner = p->subs[SUB_REAL].owner; + if (p->subs[SUB_REAL].owner && ast_bridged_channel(p->subs[SUB_REAL].owner)) + ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD); + p->subs[SUB_REAL].needunhold = 1; + dahdi_enable_ec(p); } } -winkflashdone: - update_conf(p); - break; - case SIG_EM: - case SIG_EM_E1: - case SIG_EMWINK: - case SIG_FEATD: - case SIG_SF: - case SIG_SFWINK: - case SIG_SF_FEATD: - case SIG_FXSLS: - case SIG_FXSGS: - if (option_debug) { - if (p->dialing) - ast_debug(1, "Ignoring wink on channel %d\n", p->channel); - else - ast_debug(1, "Got wink in weird state %d on channel %d\n", ast->_state, p->channel); - } - break; - case SIG_FEATDMF_TA: - switch (p->whichwink) { - case 0: - ast_debug(1, "ANI2 set to '%d' and ANI is '%s'\n", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); - snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%d%s#", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); - break; - case 1: - ast_copy_string(p->dop.dialstr, p->finaldial, sizeof(p->dop.dialstr)); - break; - case 2: - ast_log(LOG_WARNING, "Received unexpected wink on channel of type SIG_FEATDMF_TA\n"); - return NULL; - } - p->whichwink++; - /* Fall through */ - case SIG_FEATDMF: - case SIG_E911: - case SIG_FGC_CAMAMF: - case SIG_FGC_CAMA: - case SIG_FEATB: - case SIG_SF_FEATDMF: - case SIG_SF_FEATB: - /* FGD MF *Must* wait for wink */ - if (!ast_strlen_zero(p->dop.dialstr)) { - res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); - if (res < 0) { - ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); - p->dop.dialstr[0] = '\0'; - return NULL; - } else - ast_debug(1, "Sent deferred digit string: %s\n", p->dop.dialstr); - } - p->dop.dialstr[0] = '\0'; - break; - default: - ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig); } +winkflashdone: + update_conf(p); break; - case DAHDI_EVENT_HOOKCOMPLETE: - if (p->inalarm) break; - if ((p->radio || (p->oprmode < 0))) break; - if (p->waitingfordt.tv_sec) break; - switch (mysig) { - case SIG_FXSLS: /* only interesting for FXS */ - case SIG_FXSGS: - case SIG_FXSKS: - case SIG_EM: - case SIG_EM_E1: - case SIG_EMWINK: - case SIG_FEATD: - case SIG_SF: - case SIG_SFWINK: - case SIG_SF_FEATD: - if (!ast_strlen_zero(p->dop.dialstr)) { - res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); - if (res < 0) { - ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); - p->dop.dialstr[0] = '\0'; - return NULL; - } else - ast_debug(1, "Sent deferred digit string: %s\n", p->dop.dialstr); - } - p->dop.dialstr[0] = '\0'; - p->dop.op = DAHDI_DIAL_OP_REPLACE; + case SIG_EM: + case SIG_EM_E1: + case SIG_EMWINK: + case SIG_FEATD: + case SIG_SF: + case SIG_SFWINK: + case SIG_SF_FEATD: + case SIG_FXSLS: + case SIG_FXSGS: + if (p->dialing) + ast_debug(1, "Ignoring wink on channel %d\n", p->channel); + else + ast_debug(1, "Got wink in weird state %d on channel %d\n", ast->_state, p->channel); + break; + case SIG_FEATDMF_TA: + switch (p->whichwink) { + case 0: + ast_debug(1, "ANI2 set to '%d' and ANI is '%s'\n", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%d%s#", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); break; - case SIG_FEATDMF: - case SIG_FEATDMF_TA: - case SIG_E911: - case SIG_FGC_CAMA: - case SIG_FGC_CAMAMF: - case SIG_FEATB: - case SIG_SF_FEATDMF: - case SIG_SF_FEATB: - ast_debug(1, "Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->channel); - break; - default: + case 1: + ast_copy_string(p->dop.dialstr, p->finaldial, sizeof(p->dop.dialstr)); break; + case 2: + ast_log(LOG_WARNING, "Received unexpected wink on channel of type SIG_FEATDMF_TA\n"); + return NULL; } - break; - case DAHDI_EVENT_POLARITY: - /* - * If we get a Polarity Switch event, check to see - * if we should change the polarity state and - * mark the channel as UP or if this is an indication - * of remote end disconnect. - */ - if (p->polarity == POLARITY_IDLE) { - p->polarity = POLARITY_REV; - if (p->answeronpolarityswitch && - ((ast->_state == AST_STATE_DIALING) || - (ast->_state == AST_STATE_RINGING))) { - ast_debug(1, "Answering on polarity switch!\n"); - ast_setstate(p->owner, AST_STATE_UP); - if (p->hanguponpolarityswitch) { - p->polaritydelaytv = ast_tvnow(); - } + p->whichwink++; + /* Fall through */ + case SIG_FEATDMF: + case SIG_E911: + case SIG_FGC_CAMAMF: + case SIG_FGC_CAMA: + case SIG_FEATB: + case SIG_SF_FEATDMF: + case SIG_SF_FEATB: + /* FGD MF *Must* wait for wink */ + if (!ast_strlen_zero(p->dop.dialstr)) { + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; } else - ast_debug(1, "Ignore switch to REVERSED Polarity on channel %d, state %d\n", p->channel, ast->_state); + ast_debug(1, "Sent deferred digit string: %s\n", p->dop.dialstr); } - /* Removed else statement from here as it was preventing hangups from ever happening*/ - /* Added AST_STATE_RING in if statement below to deal with calling party hangups that take place when ringing */ - if (p->hanguponpolarityswitch && - (p->polarityonanswerdelay > 0) && - (p->polarity == POLARITY_REV) && - ((ast->_state == AST_STATE_UP) || (ast->_state == AST_STATE_RING)) ) { - /* Added log_debug information below to provide a better indication of what is going on */ - ast_debug(1, "Polarity Reversal event occured - DEBUG 1: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); - - if (ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) > p->polarityonanswerdelay) { - ast_debug(1, "Polarity Reversal detected and now Hanging up on channel %d\n", p->channel); - ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); - p->polarity = POLARITY_IDLE; + p->dop.dialstr[0] = '\0'; + break; + default: + ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig); + } + break; + case DAHDI_EVENT_HOOKCOMPLETE: + if (p->inalarm) break; + if ((p->radio || (p->oprmode < 0))) break; + if (p->waitingfordt.tv_sec) break; + switch (mysig) { + case SIG_FXSLS: /* only interesting for FXS */ + case SIG_FXSGS: + case SIG_FXSKS: + case SIG_EM: + case SIG_EM_E1: + case SIG_EMWINK: + case SIG_FEATD: + case SIG_SF: + case SIG_SFWINK: + case SIG_SF_FEATD: + if (!ast_strlen_zero(p->dop.dialstr)) { + res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; } else - ast_debug(1, "Polarity Reversal detected but NOT hanging up (too close to answer event) on channel %d, state %d\n", p->channel, ast->_state); - - } else { - p->polarity = POLARITY_IDLE; - ast_debug(1, "Ignoring Polarity switch to IDLE on channel %d, state %d\n", p->channel, ast->_state); + ast_debug(1, "Sent deferred digit string: %s\n", p->dop.dialstr); } - /* Added more log_debug information below to provide a better indication of what is going on */ - ast_debug(1, "Polarity Reversal event occured - DEBUG 2: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); + p->dop.dialstr[0] = '\0'; + p->dop.op = DAHDI_DIAL_OP_REPLACE; + break; + case SIG_FEATDMF: + case SIG_FEATDMF_TA: + case SIG_E911: + case SIG_FGC_CAMA: + case SIG_FGC_CAMAMF: + case SIG_FEATB: + case SIG_SF_FEATDMF: + case SIG_SF_FEATB: + ast_debug(1, "Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->channel); break; default: - ast_debug(1, "Dunno what to do with event %d on channel %d\n", res, p->channel); + break; + } + break; + case DAHDI_EVENT_POLARITY: + /* + * If we get a Polarity Switch event, check to see + * if we should change the polarity state and + * mark the channel as UP or if this is an indication + * of remote end disconnect. + */ + if (p->polarity == POLARITY_IDLE) { + p->polarity = POLARITY_REV; + if (p->answeronpolarityswitch && + ((ast->_state == AST_STATE_DIALING) || + (ast->_state == AST_STATE_RINGING))) { + ast_debug(1, "Answering on polarity switch!\n"); + ast_setstate(p->owner, AST_STATE_UP); + if (p->hanguponpolarityswitch) { + p->polaritydelaytv = ast_tvnow(); + } + } else + ast_debug(1, "Ignore switch to REVERSED Polarity on channel %d, state %d\n", p->channel, ast->_state); + } + /* Removed else statement from here as it was preventing hangups from ever happening*/ + /* Added AST_STATE_RING in if statement below to deal with calling party hangups that take place when ringing */ + if (p->hanguponpolarityswitch && + (p->polarityonanswerdelay > 0) && + (p->polarity == POLARITY_REV) && + ((ast->_state == AST_STATE_UP) || (ast->_state == AST_STATE_RING)) ) { + /* Added log_debug information below to provide a better indication of what is going on */ + ast_debug(1, "Polarity Reversal event occured - DEBUG 1: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); + + if (ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) > p->polarityonanswerdelay) { + ast_debug(1, "Polarity Reversal detected and now Hanging up on channel %d\n", p->channel); + ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); + p->polarity = POLARITY_IDLE; + } else + ast_debug(1, "Polarity Reversal detected but NOT hanging up (too close to answer event) on channel %d, state %d\n", p->channel, ast->_state); + + } else { + p->polarity = POLARITY_IDLE; + ast_debug(1, "Ignoring Polarity switch to IDLE on channel %d, state %d\n", p->channel, ast->_state); + } + /* Added more log_debug information below to provide a better indication of what is going on */ + ast_debug(1, "Polarity Reversal event occured - DEBUG 2: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); + break; + default: + ast_debug(1, "Dunno what to do with event %d on channel %d\n", res, p->channel); } return &p->subs[idx].f; } @@ -6890,7 +7842,12 @@ static struct ast_frame *dahdi_exception(struct ast_channel *ast) struct dahdi_pvt *p = ast->tech_pvt; struct ast_frame *f; ast_mutex_lock(&p->lock); - f = __dahdi_exception(ast); + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + struct analog_pvt *analog_p = p->sig_pvt; + f = analog_exception(analog_p, ast); + } else { + f = __dahdi_exception(ast); + } ast_mutex_unlock(&p->lock); return f; } @@ -7138,7 +8095,7 @@ static struct ast_frame *dahdi_read(struct ast_channel *ast) p->subs[idx].f.datalen = READ_SIZE; /* Handle CallerID Transmission */ - if ((p->owner == ast) && p->cidspill &&((ast->_state == AST_STATE_UP) || (ast->rings == p->cidrings))) { + if ((p->owner == ast) && p->cidspill) { send_callerid(p); } @@ -7151,7 +8108,9 @@ static struct ast_frame *dahdi_read(struct ast_channel *ast) #if 0 ast_debug(1, "Read %d of voice on %s\n", p->subs[idx].f.datalen, ast->name); #endif - if (p->dialing || /* Transmitting something */ + { + struct analog_pvt *ap = p->sig_pvt; + if ((analog_lib_handles(p->sig ,p->radio, p->oprmode) && ap->dialing) || p->dialing || p->radio || /* Transmitting something */ (idx && (ast->_state != AST_STATE_UP)) || /* Three-way or callwait that isn't up */ ((idx == SUB_CALLWAIT) && !p->subs[SUB_CALLWAIT].inthreeway) /* Inactive and non-confed call-wait */ ) { @@ -7165,6 +8124,7 @@ static struct ast_frame *dahdi_read(struct ast_channel *ast) p->subs[idx].f.data.ptr = NULL; p->subs[idx].f.datalen= 0; } + } if (p->dsp && (!p->ignoredtmf || p->callwaitcas || p->busydetect || p->callprogress || p->waitingfordt.tv_sec) && !idx) { /* Perform busy detection etc on the dahdi line */ int mute; @@ -7231,8 +8191,12 @@ static struct ast_frame *dahdi_read(struct ast_channel *ast) } else f = &p->subs[idx].f; - if (f && (f->frametype == AST_FRAME_DTMF)) - dahdi_handle_dtmfup(ast, idx, &f); + if (f && (f->frametype == AST_FRAME_DTMF)) { + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + analog_handle_dtmfup(p->sig_pvt, ast, idx, &f); + } else + dahdi_handle_dtmfup(ast, idx, &f); + } /* If we have a fake_event, trigger exception to handle it */ if (p->fake_event) @@ -7303,6 +8267,12 @@ static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame) ast_log(LOG_WARNING, "Cannot handle frames in %d format\n", frame->subclass); return -1; } + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + struct analog_pvt *ap = p->sig_pvt; + + if (ap->dialing) + return 0; + } if (p->dialing) { ast_debug(1, "Dropping frame since I'm still dialing on %s...\n",ast->name); return 0; @@ -7849,7 +8819,7 @@ static void dahdi_dnd(struct dahdi_pvt *dahdichan, int on) on? "enabled" : "disabled"); } -static void *ss_thread(void *data) +static void *analog_ss_thread(void *data) { struct ast_channel *chan = data; struct dahdi_pvt *p = chan->tech_pvt; @@ -9008,24 +9978,8 @@ static void *ss_thread(void *data) if (cs) callerid_free(cs); - /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */ - if (flags & CID_MSGWAITING) { - ast_log(LOG_NOTICE, "MWI: Channel %d message waiting!\n", p->channel); - notify_message(p->mailbox, 1); - /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */ - if (p->mwimonitor_rpas) { - ast_hangup(chan); - return NULL; - } - } else if (flags & CID_NOMSGWAITING) { - ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting!\n", p->channel); - notify_message(p->mailbox, 0); - /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */ - if (p->mwimonitor_rpas) { - ast_hangup(chan); - return NULL; - } - } + + my_handle_notify_message(chan, p, flags, -1); ast_setstate(chan, AST_STATE_RING); chan->rings = 1; @@ -9129,14 +10083,20 @@ static void *mwi_thread(void *data) handle_alarms(mtd->pvt, res); break; /* What to do on channel alarm ???? -- fall thru intentionally?? */ default: - ast_log(LOG_NOTICE, "Got event %d (%s)... Passing along to ss_thread\n", res, event2str(res)); + ast_log(LOG_NOTICE, "Got event %d (%s)... Passing along to analog_ss_thread\n", res, event2str(res)); callerid_free(cs); restore_gains(mtd->pvt); mtd->pvt->ringt = mtd->pvt->ringt_base; if ((chan = dahdi_new(mtd->pvt, AST_STATE_RING, 0, SUB_REAL, 0, 0))) { - if (ast_pthread_create_detached(&threadid, NULL, ss_thread, chan)) { + int result; + if (analog_lib_handles(mtd->pvt->sig, mtd->pvt->radio, mtd->pvt->oprmode)) { + result = analog_ss_thread_start(mtd->pvt->sig_pvt, chan); + } else { + result = ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, chan); + } + if (result) { ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", mtd->pvt->channel); res = tone_zone_play_tone(mtd->pvt->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION); if (res < 0) @@ -9407,7 +10367,7 @@ static int dahdi_destroy_channel_bynum(int channel) while (tmp) { if (tmp->channel == channel) { int x = DAHDI_FLASH; - ioctl(tmp->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); /* important to create an event for dahdi_wait_event to register so that all ss_threads terminate */ + ioctl(tmp->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); /* important to create an event for dahdi_wait_event to register so that all analog_ss_threads terminate */ destroy_channel(prev, tmp, 1); ast_module_unref(ast_module_info->self); return RESULT_SUCCESS; @@ -9471,7 +10431,7 @@ static int handle_init_event(struct dahdi_pvt *i, int event) res = tone_zone_play_tone(i->subs[SUB_REAL].dfd, DAHDI_TONE_DIALTONE); if (res < 0) ast_log(LOG_WARNING, "Unable to play dialtone on channel %d, do you have defaultzone and loadzone defined?\n", i->channel); - if (ast_pthread_create_detached(&threadid, NULL, ss_thread, chan)) { + if (ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, chan)) { ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); res = tone_zone_play_tone(i->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION); if (res < 0) @@ -9513,7 +10473,7 @@ static int handle_init_event(struct dahdi_pvt *i, int event) if (!chan) { ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", i->channel); - } else if (ast_pthread_create_detached(&threadid, NULL, ss_thread, chan)) { + } else if (ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, chan)) { ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); res = tone_zone_play_tone(i->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION); if (res < 0) { @@ -9619,7 +10579,7 @@ static int handle_init_event(struct dahdi_pvt *i, int event) chan = dahdi_new(i, AST_STATE_PRERING, 0, SUB_REAL, 0, 0); if (!chan) { ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", i->channel); - } else if (ast_pthread_create_detached(&threadid, NULL, ss_thread, chan)) { + } else if (ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, chan)) { ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); } else { thread_spawned = 1; @@ -9697,19 +10657,39 @@ static void *do_monitor(void *data) count = 0; i = iflist; while (i) { + ast_mutex_lock(&i->lock); if ((i->subs[SUB_REAL].dfd > -1) && i->sig && (!i->radio) && !(i->sig & SIG_MFCR2)) { - if (!i->owner && !i->subs[SUB_REAL].owner && !i->mwimonitoractive ) { - /* This needs to be watched, as it lacks an owner */ - pfds[count].fd = i->subs[SUB_REAL].dfd; - pfds[count].events = POLLPRI; - pfds[count].revents = 0; - /* If we are monitoring for VMWI or sending CID, we need to - read from the channel as well */ - if (i->cidspill || i->mwisendactive || i->mwimonitor_fsk) - pfds[count].events |= POLLIN; - count++; + if (analog_lib_handles(i->sig, i->radio, i->oprmode)) { + struct analog_pvt *p = i->sig_pvt; + + if (!p) + ast_log(LOG_ERROR, "No sig_pvt?\n"); + + if (!p->owner && !p->subs[SUB_REAL].owner) { + /* This needs to be watched, as it lacks an owner */ + pfds[count].fd = i->subs[SUB_REAL].dfd; + pfds[count].events = POLLPRI; + pfds[count].revents = 0; + /* Message waiting or r2 channels also get watched for reading */ + if (i->cidspill || i->mwisendactive || i->mwimonitor_fsk) + pfds[count].events |= POLLIN; + count++; + } + } else { + if (!i->owner && !i->subs[SUB_REAL].owner && !i->mwimonitoractive ) { + /* This needs to be watched, as it lacks an owner */ + pfds[count].fd = i->subs[SUB_REAL].dfd; + pfds[count].events = POLLPRI; + pfds[count].revents = 0; + /* If we are monitoring for VMWI or sending CID, we need to + read from the channel as well */ + if (i->cidspill || i->mwisendactive || i->mwimonitor_fsk) + pfds[count].events |= POLLIN; + count++; + } } } + ast_mutex_unlock(&i->lock); i = i->next; } /* Okay, now that we know what to do, release the interface lock */ @@ -9774,7 +10754,10 @@ static void *do_monitor(void *data) ast_debug(1, "Monitor doohicky got event %s on radio channel %d\n", event2str(res), i->channel); /* Don't hold iflock while handling init events */ ast_mutex_unlock(&iflock); - handle_init_event(i, res); + if (analog_lib_handles(i->sig, i->radio, i->oprmode)) + analog_handle_init_event(i->sig_pvt, dahdievent_to_analogevent(res)); + else + handle_init_event(i, res); ast_mutex_lock(&iflock); } i = i->next; @@ -9840,7 +10823,10 @@ static void *do_monitor(void *data) /* Don't hold iflock while handling init events */ ast_mutex_unlock(&iflock); if (0 == i->mwisendactive || 0 == mwi_send_process_event(i, res)) { - handle_init_event(i, res); + if (analog_lib_handles(i->sig, i->radio, i->oprmode)) + analog_handle_init_event(i->sig_pvt, dahdievent_to_analogevent(res)); + else + handle_init_event(i, res); } ast_mutex_lock(&iflock); } @@ -10151,6 +11137,7 @@ static struct dahdi_pvt *mkintf(int channel, const struct dahdi_chan_conf *conf, int x; struct dahdi_pvt **wlist; struct dahdi_pvt **wend; + struct analog_pvt *analog_p = NULL; struct dahdi_params p; wlist = &iflist; @@ -10236,6 +11223,20 @@ static struct dahdi_pvt *mkintf(int channel, const struct dahdi_chan_conf *conf, return NULL; } } + + if (analog_lib_handles(chan_sig, tmp->radio, tmp->oprmode)) { + if (tmp->sig_pvt) { + ast_log(LOG_WARNING, "Private already exists!\n"); + analog_p = tmp->sig_pvt; + } else + analog_p = analog_new(dahdisig_to_analogsig(chan_sig), &dahdi_analog_callbacks, tmp); + if (!analog_p) { + destroy_dahdi_pvt(&tmp); + return NULL; + } + tmp->sig_pvt = analog_p; + + } #ifdef HAVE_SS7 if (chan_sig == SIG_SS7) { struct dahdi_ss7 *ss7; @@ -10740,11 +11741,44 @@ static struct dahdi_pvt *mkintf(int channel, const struct dahdi_chan_conf *conf, } } #endif - } else { + } else { /* We default to in service on protocols that don't have a reset */ tmp->inservice = 1; } } + + analog_p = tmp->sig_pvt; + if (analog_p) { + analog_p->channel = tmp->channel; + analog_p->polarityonanswerdelay = conf->chan.polarityonanswerdelay; + analog_p->answeronpolarityswitch = conf->chan.answeronpolarityswitch; + analog_p->hanguponpolarityswitch = conf->chan.hanguponpolarityswitch; + analog_p->sendcalleridafter = conf->chan.sendcalleridafter; + analog_p->permcallwaiting = 1; + analog_p->callreturn = conf->chan.callreturn; + analog_p->cancallforward = conf->chan.cancallforward; + analog_p->canpark = conf->chan.canpark; + analog_p->dahditrcallerid = conf->chan.dahditrcallerid; + analog_p->immediate = conf->chan.immediate; + analog_p->permhidecallerid = conf->chan.permhidecallerid; + analog_p->pulse = conf->chan.pulse; + analog_p->threewaycalling = conf->chan.threewaycalling; + analog_p->transfer = conf->chan.transfer; + analog_p->transfertobusy = conf->chan.transfertobusy; + analog_p->use_callerid = conf->chan.use_callerid; + analog_p->outsigmod = ANALOG_SIG_NONE; + analog_p->echotraining = conf->chan.echotraining; + analog_p->cid_signalling = conf->chan.cid_signalling; + analog_p->stripmsd = conf->chan.stripmsd; + analog_p->cid_start = ANALOG_CID_START_RING; + tmp->callwaitingcallerid = analog_p->callwaitingcallerid = 1; + + ast_copy_string(analog_p->mohsuggest, conf->chan.mohsuggest, sizeof(analog_p->mohsuggest)); + ast_copy_string(analog_p->cid_num, conf->chan.cid_num, sizeof(analog_p->cid_num)); + ast_copy_string(analog_p->cid_name, conf->chan.cid_name, sizeof(analog_p->cid_name)); + + analog_config_complete(analog_p); + } } if (tmp && !here) { /* nothing on the iflist */ @@ -10810,6 +11844,10 @@ static inline int available(struct dahdi_pvt *p, int channelmatch, ast_group_t g return 0; *channelmatched = 1; } + + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) + return analog_available(p->sig_pvt, channelmatch, groupmatch, reason, channelmatched, groupmatched); + /* We're at least busy at this point */ if (reason) { if ((p->sig == SIG_FXOKS) || (p->sig == SIG_FXOLS) || (p->sig == SIG_FXOGS)) @@ -11193,7 +12231,10 @@ static struct ast_channel *dahdi_request(const char *type, int format, void *dat } } p->outgoing = 1; - tmp = dahdi_new(p, AST_STATE_RESERVED, 0, p->owner ? SUB_CALLWAIT : SUB_REAL, 0, 0); + if (analog_lib_handles(p->sig, p->radio, p->oprmode)) { + tmp = analog_request(p->sig_pvt, &callwait); + } else + tmp = dahdi_new(p, AST_STATE_RESERVED, 0, p->owner ? SUB_CALLWAIT : SUB_REAL, 0, 0); #ifdef HAVE_PRI if (p->bearer) { /* Log owner to bearer channel, too */ @@ -11258,7 +12299,11 @@ next: #if defined(HAVE_PRI) || defined(HAVE_SS7) static int dahdi_setlaw(int dfd, int law) { - return ioctl(dfd, DAHDI_SETLAW, &law); + int res; + res = ioctl(dfd, DAHDI_SETLAW, &law); + if (res) + return res; + return 0; } #endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */ @@ -13219,7 +14264,7 @@ static void *pri_dchannel(void *vpri) ast_mutex_lock(&pri->pvts[chanpos]->lock); ast_mutex_lock(&pri->lock); - if (c && !ast_pthread_create_detached(&threadid, NULL, ss_thread, c)) { + if (c && !ast_pthread_create_detached(&threadid, NULL, analog_ss_thread, c)) { ast_verb(3, "Accepting overlap call from '%s' to '%s' on channel %d/%d, span %d\n", plancallingnum, S_OR(pri->pvts[chanpos]->exten, "<unspecified>"), pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span); @@ -14788,14 +15833,14 @@ static int dahdi_restart(void) ast_mutex_lock(&ss_thread_lock); while (ss_thread_count > 0) { /* let ss_threads finish and run dahdi_hangup before dahvi_pvts are destroyed */ int x = DAHDI_FLASH; - ast_debug(3, "Waiting on %d ss_thread(s) to finish\n", ss_thread_count); + ast_debug(3, "Waiting on %d analog_ss_thread(s) to finish\n", ss_thread_count); for (p = iflist; p; p = p->next) { if (p->owner) - ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); /* important to create an event for dahdi_wait_event to register so that all ss_threads terminate */ + ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x); /* important to create an event for dahdi_wait_event to register so that all analog_ss_threads terminate */ } - ast_cond_wait(&ss_thread_complete, &ss_thread_lock); - } + ast_cond_wait(&ss_thread_complete, &ss_thread_lock); + } /* ensure any created channels before monitor threads were stopped are hungup */ dahdi_softhangup_all(); @@ -15583,14 +16628,14 @@ static int dahdi_fake_event(struct dahdi_pvt *p, int mode) { if (p) { switch (mode) { - case TRANSFER: - p->fake_event = DAHDI_EVENT_WINKFLASH; - break; - case HANGUP: - p->fake_event = DAHDI_EVENT_ONHOOK; - break; - default: - ast_log(LOG_WARNING, "I don't know how to handle transfer event with this: %d on channel %s\n",mode, p->owner->name); + case TRANSFER: + p->fake_event = DAHDI_EVENT_WINKFLASH; + break; + case HANGUP: + p->fake_event = DAHDI_EVENT_ONHOOK; + break; + default: + ast_log(LOG_WARNING, "I don't know how to handle transfer event with this: %d on channel %s\n",mode, p->owner->name); } } return 0; @@ -17847,6 +18892,7 @@ static int reload(void) return 0; } + /* This is a workaround so that menuselect displays a proper description * AST_MODULE_INFO(, , "DAHDI Telephony" */ diff --git a/channels/sig_analog.c b/channels/sig_analog.c new file mode 100644 index 000000000..8cdec1a02 --- /dev/null +++ b/channels/sig_analog.c @@ -0,0 +1,3262 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2009, Digium, Inc. + * + * Mark Spencer <markster@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Analog signaling module + * + * \author Matthew Fredrickson <creslin@digium.com> + */ + +#include "asterisk.h" + +#include <errno.h> +#include <ctype.h> + +#include "asterisk/utils.h" +#include "asterisk/options.h" +#include "asterisk/pbx.h" +#include "asterisk/file.h" +#include "asterisk/callerid.h" +#include "asterisk/say.h" +#include "asterisk/manager.h" +#include "asterisk/astdb.h" +#include "asterisk/features.h" + +#include "sig_analog.h" + +#define POLARITY_IDLE 0 +#define POLARITY_REV 1 +#define MIN_MS_SINCE_FLASH ( (2000) ) /*!< 2000 ms */ +static int analog_matchdigittimeout = 3000; +static int analog_gendigittimeout = 8000; +static int analog_firstdigittimeout = 16000; +static char analog_defaultcic[64] = ""; +static char analog_defaultozz[64] = ""; + +static const struct { + enum analog_sigtype sigtype; + const char const *name; +} sigtypes[] = { + { ANALOG_SIG_FXOLS, "fxo_ls" }, + { ANALOG_SIG_FXOKS, "fxo_ks" }, + { ANALOG_SIG_FXOGS, "fxo_gs" }, + { ANALOG_SIG_FXSLS, "fxs_ls" }, + { ANALOG_SIG_FXSKS, "fxs_ks" }, + { ANALOG_SIG_FXSGS, "fxs_gs" }, + { ANALOG_SIG_EMWINK, "em_w" }, + { ANALOG_SIG_EM, "em" }, + { ANALOG_SIG_EM_E1, "em_e1" }, + { ANALOG_SIG_FEATD, "featd" }, + { ANALOG_SIG_FEATDMF, "featdmf" }, + { ANALOG_SIG_FEATDMF_TA, "featdmf_ta" }, + { ANALOG_SIG_FEATB, "featb" }, + { ANALOG_SIG_FGC_CAMA, "fgccama" }, + { ANALOG_SIG_FGC_CAMAMF, "fgccamamf" }, + { ANALOG_SIG_SF, "sf" }, + { ANALOG_SIG_SFWINK, "sf_w" }, + { ANALOG_SIG_SF_FEATD, "sf_featd" }, + { ANALOG_SIG_SF_FEATDMF, "sf_featdmf" }, + { ANALOG_SIG_SF_FEATB, "sf_featb" }, + { ANALOG_SIG_E911, "e911" }, +}; + +static const struct { + unsigned int cid_type; + const char const *name; +} cidtypes[] = { + { CID_SIG_BELL, "bell" }, + { CID_SIG_V23, "v23" }, + { CID_SIG_V23_JP, "v23_jp" }, + { CID_SIG_DTMF, "dtmf" }, + /* "smdi" is intentionally not supported here, as there is a much better + * way to do this in the dialplan now. */ +}; + +enum analog_sigtype analog_str_to_sigtype(const char *name) +{ + int i; + + for (i = 0; i < ARRAY_LEN(sigtypes); i++) { + if (!strcasecmp(sigtypes[i].name, name)) { + return sigtypes[i].sigtype; + } + } + + return 0; +} + +const char *analog_sigtype_to_str(enum analog_sigtype sigtype) +{ + int i; + + for (i = 0; i < ARRAY_LEN(sigtypes); i++) { + if (sigtype == sigtypes[i].sigtype) { + return sigtypes[i].name; + } + } + + return "Unknown"; +} + +unsigned int analog_str_to_cidtype(const char *name) +{ + int i; + + for (i = 0; i < ARRAY_LEN(cidtypes); i++) { + if (!strcasecmp(cidtypes[i].name, name)) { + return cidtypes[i].cid_type; + } + } + + return 0; +} + +const char *analog_cidtype_to_str(unsigned int cid_type) +{ + int i; + + for (i = 0; i < ARRAY_LEN(cidtypes); i++) { + if (cid_type == cidtypes[i].cid_type) { + return cidtypes[i].name; + } + } + + return "Unknown"; +} + +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); + else + 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); + else + 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); + else + return -1; +} + +static int analog_get_event(struct analog_pvt *p) +{ + if (p->calls->get_event) + return p->calls->get_event(p->chan_pvt); + else + return -1; +} + +static int analog_wait_event(struct analog_pvt *p) +{ + if (p->calls->wait_event) + return p->calls->wait_event(p->chan_pvt); + else + return -1; +} + +enum analog_cid_start analog_str_to_cidstart(const char *value) +{ + if (!strcasecmp(value, "ring")) { + return ANALOG_CID_START_RING; + } else if (!strcasecmp(value, "polarity")) { + return ANALOG_CID_START_POLARITY; + } else if (!strcasecmp(value, "polarity_in")) { + return ANALOG_CID_START_POLARITY_IN; + } + + return 0; +} + +const char *analog_cidstart_to_str(enum analog_cid_start cid_start) +{ + switch (cid_start) { + case ANALOG_CID_START_RING: + return "Ring"; + case ANALOG_CID_START_POLARITY: + return "Polarity"; + case ANALOG_CID_START_POLARITY_IN: + return "Polarity_In"; + } + + return "Unknown"; +} + +static char *analog_event2str(enum analog_event event) +{ + char *res; + switch (event) { + case ANALOG_EVENT_DIALCOMPLETE: + res = "ANALOG_EVENT_DIALCOMPLETE"; + break; + case ANALOG_EVENT_WINKFLASH: + res = "ANALOG_EVENT_WINKFLASH"; + break; + case ANALOG_EVENT_ONHOOK: + res = "ANALOG_EVENT_ONHOOK"; + break; + case ANALOG_EVENT_RINGOFFHOOK: + res = "ANALOG_EVENT_RINGOFFHOOK"; + break; + case ANALOG_EVENT_ALARM: + res = "ANALOG_EVENT_ALARM"; + break; + case ANALOG_EVENT_NOALARM: + res = "ANALOG_EVENT_NOALARM"; + break; + case ANALOG_EVENT_HOOKCOMPLETE: + res = "ANALOG_EVENT_HOOKCOMPLETE"; + break; + case ANALOG_EVENT_POLARITY: + res = "ANALOG_EVENT_POLARITY"; + break; + case ANALOG_EVENT_RINGERON: + res = "ANALOG_EVENT_RINGERON"; + break; + case ANALOG_EVENT_RINGEROFF: + res = "ANALOG_EVENT_RINGEROFF"; + break; + case ANALOG_EVENT_RINGBEGIN: + res = "ANALOG_EVENT_RINGBEGIN"; + break; + case ANALOG_EVENT_PULSE_START: + res = "ANALOG_EVENT_PULSE_START"; + break; + case ANALOG_EVENT_NEONMWI_ACTIVE: + res = "ANALOG_EVENT_NEONMWI_ACTIVE"; + break; + case ANALOG_EVENT_NEONMWI_INACTIVE: + res = "ANALOG_EVENT_NEONMWI_INACTIVE"; + break; + default: + res = "UNKNOWN/OTHER"; + break; + } + + return res; +} + +static void analog_swap_subs(struct analog_pvt *p, enum analog_sub a, enum analog_sub b) +{ + int tinthreeway; + struct ast_channel *towner; + + ast_debug(1, "Swapping %d and %d\n", a, b); + + towner = p->subs[a].owner; + tinthreeway = p->subs[a].inthreeway; + + p->subs[a].owner = p->subs[b].owner; + p->subs[a].inthreeway = p->subs[b].inthreeway; + + p->subs[b].owner = towner; + 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); + +} + +static int analog_alloc_sub(struct analog_pvt *p, enum analog_sub x) +{ + p->subs[x].allocd = 1; + if (p->calls->allocate_sub) + return p->calls->allocate_sub(p->chan_pvt, x); + + return 0; +} + +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); + + return 0; +} + +static int analog_send_callerid(struct analog_pvt *p, int cwcid, struct ast_callerid *cid) +{ + ast_debug(1, "Sending callerid. CID_NAME: '%s' CID_NUM: '%s'\n", cid->cid_name, cid->cid_num); + + if (cwcid) { + p->callwaitcas = 0; + } + + if (p->calls->send_callerid) + return p->calls->send_callerid(p->chan_pvt, cwcid, cid); + else + return 0; +} + +static int analog_get_index(struct ast_channel *ast, struct analog_pvt *p, int nullok) +{ + int res; + if (p->subs[ANALOG_SUB_REAL].owner == ast) + res = ANALOG_SUB_REAL; + else if (p->subs[ANALOG_SUB_CALLWAIT].owner == ast) + res = ANALOG_SUB_CALLWAIT; + else if (p->subs[ANALOG_SUB_THREEWAY].owner == ast) + res = ANALOG_SUB_THREEWAY; + else { + res = -1; + if (!nullok) + ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n"); + } + return res; +} + +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); + else + /* Return 0 since I think this is unnecessary to do in most cases it is used. Mostly only for ast_dsp */ + return 0; +} + +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); + else + return -1; +} + +static struct ast_channel * analog_new_ast_channel(struct analog_pvt *p, int state, int startpbx, enum analog_sub sub) +{ + struct ast_channel *c; + + if (p->calls->new_ast_channel) + c = p->calls->new_ast_channel(p->chan_pvt, state, startpbx, sub); + else + return NULL; + + p->subs[sub].owner = c; + if (!p->owner) + p->owner = c; + return c; +} + +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); + else + return -1; +} + +static int analog_train_echocanceller(struct analog_pvt *p) +{ + if (p->calls->train_echocanceller) + return p->calls->train_echocanceller(p->chan_pvt); + else + 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); + else + return -1; +} + +static int analog_ring(struct analog_pvt *p) +{ + if (p->calls->ring) + return p->calls->ring(p->chan_pvt); + else + return -1; +} + +static int analog_start(struct analog_pvt *p) +{ + if (p->calls->start) + return p->calls->start(p->chan_pvt); + else + 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); + else + return -1; +} + +static int analog_on_hook(struct analog_pvt *p) +{ + if (p->calls->on_hook) + return p->calls->on_hook(p->chan_pvt); + else + return -1; +} + +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); + else + 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); +} + +static void analog_unlock_private(struct analog_pvt *p) +{ + if (p->calls->unlock_private) + p->calls->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); +} + +static int analog_off_hook(struct analog_pvt *p) +{ + if (p->calls->off_hook) + return p->calls->off_hook(p->chan_pvt); + else + return -1; +} + +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); + else + return -1; +} + +static void analog_cb_handle_dtmfup(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest) +{ + if (p->calls->handle_dtmfup) + p->calls->handle_dtmfup(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); + else + return -1; +} + +static int analog_has_voicemail(struct analog_pvt *p) +{ + if (p->calls->has_voicemail) + return p->calls->has_voicemail(p->chan_pvt); + else + 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); + else + return -1; +} + +static int analog_attempt_transfer(struct analog_pvt *p) +{ + /* In order to transfer, we need at least one of the channels to + actually be in a call bridge. We can't conference two applications + together (but then, why would we want to?) */ + if (ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)) { + /* The three-way person we're about to transfer to could still be in MOH, so + stop if now if appropriate */ + if (ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)) + ast_queue_control(p->subs[ANALOG_SUB_THREEWAY].owner, AST_CONTROL_UNHOLD); + if (p->subs[ANALOG_SUB_REAL].owner->_state == AST_STATE_RINGING) { + ast_indicate(ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner), AST_CONTROL_RINGING); + } + if (p->subs[ANALOG_SUB_THREEWAY].owner->_state == AST_STATE_RING) { + analog_play_tone(p, ANALOG_SUB_THREEWAY, ANALOG_TONE_RINGTONE); + } + if (ast_channel_masquerade(p->subs[ANALOG_SUB_THREEWAY].owner, ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner))) { + ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n", + ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)->name, p->subs[ANALOG_SUB_THREEWAY].owner->name); + return -1; + } + /* Orphan the channel after releasing the lock */ + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + } else if (ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)) { + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_UNHOLD); + if (p->subs[ANALOG_SUB_THREEWAY].owner->_state == AST_STATE_RINGING) { + ast_indicate(ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner), AST_CONTROL_RINGING); + } + if (p->subs[ANALOG_SUB_REAL].owner->_state == AST_STATE_RING) { + analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_RINGTONE); + } + if (ast_channel_masquerade(p->subs[ANALOG_SUB_REAL].owner, ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner))) { + ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n", + ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)->name, p->subs[ANALOG_SUB_REAL].owner->name); + return -1; + } + /* Three-way is now the REAL */ + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + /* Tell the caller not to hangup */ + return 1; + } else { + ast_debug(1, "Neither %s nor %s are in a bridge, nothing to transfer\n", + p->subs[ANALOG_SUB_REAL].owner->name, p->subs[ANALOG_SUB_THREEWAY].owner->name); + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + return -1; + } + return 0; +} + +static int analog_update_conf(struct analog_pvt *p) +{ + int x; + int needconf = 0; + + /* Start with the obvious, general stuff */ + 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); + needconf++; + } else { + if (p->calls->conf_del) + p->calls->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); + return 0; +} + +struct ast_channel * analog_request(struct analog_pvt *p, int *callwait) +{ + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + *callwait = (p->owner != NULL); + + if (p->owner) { + if (analog_alloc_sub(p, ANALOG_SUB_CALLWAIT)) { + ast_log(LOG_ERROR, "Unable to alloc subchannel\n"); + return NULL; + } + } + + return analog_new_ast_channel(p, AST_STATE_RESERVED, 0, p->owner ? ANALOG_SUB_CALLWAIT : ANALOG_SUB_REAL); +} + +int analog_available(struct analog_pvt *p, int channelmatch, ast_group_t groupmatch, int *busy, int *channelmatched, int *groupmatched) +{ + int offhook; + + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + /* We're at least busy at this point */ + if (busy) { + if ((p->sig == ANALOG_SIG_FXOKS) || (p->sig == ANALOG_SIG_FXOLS) || (p->sig == ANALOG_SIG_FXOGS)) + *busy = 1; + } + /* If do not disturb, definitely not */ + if (p->dnd) + return 0; + /* If guard time, definitely not */ + if (p->guardtime && (time(NULL) < p->guardtime)) + return 0; + + /* If no owner definitely available */ + if (!p->owner) { + if (p->sig == ANALOG_SIG_FXSLS) + return 1; + + offhook = analog_is_off_hook(p); + + if ((p->sig == ANALOG_SIG_FXSKS) || (p->sig == ANALOG_SIG_FXSGS)) { + /* When "onhook" that means no battery on the line, and thus + it is out of service..., if it's on a TDM card... If it's a channel + bank, there is no telling... */ + if (offhook) + return 1; + else + return 0; + } else if (offhook) { + ast_debug(1, "Channel %d off hook, can't use\n", p->channel); + /* Not available when the other end is off hook */ + return 0; + } + return 1; + } + + /* If it's not an FXO, forget about call wait */ + if ((p->sig != ANALOG_SIG_FXOKS) && (p->sig != ANALOG_SIG_FXOLS) && (p->sig != ANALOG_SIG_FXOGS)) + return 0; + + if (!p->callwaiting) { + /* If they don't have call waiting enabled, then for sure they're unavailable at this point */ + return 0; + } + + if (p->subs[ANALOG_SUB_CALLWAIT].allocd) { + /* If there is already a call waiting call, then we can't take a second one */ + return 0; + } + + if ((p->owner->_state != AST_STATE_UP) && + ((p->owner->_state != AST_STATE_RINGING) || p->outgoing)) { + /* If the current call is not up, then don't allow the call */ + return 0; + } + if ((p->subs[ANALOG_SUB_THREEWAY].owner) && (!p->subs[ANALOG_SUB_THREEWAY].inthreeway)) { + /* Can't take a call wait when the three way calling hasn't been merged yet. */ + return 0; + } + /* We're cool */ + return 1; +} + +static int analog_stop_callwait(struct analog_pvt *p) +{ + if (p->callwaitingcallerid) + p->callwaitcas = 0; + + if (p->calls->stop_callwait) + return p->calls->stop_callwait(p->chan_pvt); + else + return 0; +} + +static int analog_callwait(struct analog_pvt *p) +{ + if (p->callwaitingcallerid) + p->callwaitcas = 1; + if (p->calls->callwait) + return p->calls->callwait(p->chan_pvt); + else + return 0; +} + +int analog_call(struct analog_pvt *p, struct ast_channel *ast, char *rdest, int timeout) +{ + int res, index,mysig; + char *c, *n, *l; + char dest[256]; /* must be same length as p->dialdest */ + + ast_log(LOG_DEBUG, "CALLING CID_NAME: %s CID_NUM:: %s\n", ast->connected.id.name, ast->connected.id.number); + + ast_copy_string(dest, rdest, sizeof(dest)); + ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest)); + + if ((ast->_state == AST_STATE_BUSY)) { + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_BUSY); + return 0; + } + + if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) { + ast_log(LOG_WARNING, "analog_call called on %s, neither down nor reserved\n", ast->name); + return -1; + } + + p->dialednone = 0; + + mysig = p->sig; + if (p->outsigmod > -1) + mysig = p->outsigmod; + + switch (mysig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + if (p->owner == ast) { + /* Normal ring, on hook */ + + /* Don't send audio while on hook, until the call is answered */ + p->dialing = 1; + /* XXX */ +#if 0 + /* Choose proper cadence */ + if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) { + if (ioctl(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1])) + ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast->name, strerror(errno)); + p->cidrings = cidrings[p->distinctivering - 1]; + } else { + if (ioctl(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_SETCADENCE, NULL)) + ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast->name, strerror(errno)); + p->cidrings = p->sendcalleridafter; + } +#endif + p->cidrings = p->sendcalleridafter; + + /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */ + c = strchr(dest, '/'); + if (c) + c++; + if (c && (strlen(c) < p->stripmsd)) { + ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd); + c = NULL; + } + if (c) { + p->dop.op = ANALOG_DIAL_OP_REPLACE; + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c); + ast_debug(1, "FXO: setup deferred dialstring: %s\n", c); + } else { + p->dop.dialstr[0] = '\0'; + } + + if (analog_ring(p)) { + ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno)); + return -1; + } + p->dialing = 1; + } else { + if (ast->connected.id.number) + ast_copy_string(p->callwait_num, ast->connected.id.number, sizeof(p->callwait_num)); + else + p->callwait_num[0] = '\0'; + if (ast->connected.id.name) + ast_copy_string(p->callwait_name, ast->connected.id.name, sizeof(p->callwait_name)); + else + p->callwait_name[0] = '\0'; + + /* Call waiting tone instead */ + if (analog_callwait(p)) { + return -1; + } + /* Make ring-back */ + if (analog_play_tone(p, ANALOG_SUB_CALLWAIT, ANALOG_TONE_RINGTONE)) + ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast->name); + + } + n = ast->connected.id.name; + l = ast->connected.id.number; + if (l) + ast_copy_string(p->lastcid_num, l, sizeof(p->lastcid_num)); + else + p->lastcid_num[0] = '\0'; + if (n) + ast_copy_string(p->lastcid_name, n, sizeof(p->lastcid_name)); + else + p->lastcid_name[0] = '\0'; + + if (p->use_callerid) { + //p->callwaitcas = 0; + p->cid.cid_name = p->lastcid_name; + p->cid.cid_num = p->lastcid_num; + } + + + ast_setstate(ast, AST_STATE_RINGING); + index = analog_get_index(ast, p, 0); + if (index > -1) { + ast_queue_control(p->subs[index].owner, AST_CONTROL_RINGING); + } + break; + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_SF_FEATB: + c = strchr(dest, '/'); + if (c) + c++; + else + c = ""; + if (strlen(c) < p->stripmsd) { + ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd); + return -1; + } + res = analog_start(p); + if (res < 0) { + if (errno != EINPROGRESS) { + return -1; + } + } + ast_log(LOG_DEBUG, "Dialing '%s'\n", c); + p->dop.op = ANALOG_DIAL_OP_REPLACE; + + c += p->stripmsd; + + switch (mysig) { + case ANALOG_SIG_FEATD: + l = ast->connected.id.number; + if (l) + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c); + else + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c); + break; + case ANALOG_SIG_FEATDMF: + l = ast->connected.id.number; + if (l) + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c); + else + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c); + break; + case ANALOG_SIG_FEATDMF_TA: + { + const char *cic = "", *ozz = ""; + + /* If you have to go through a Tandem Access point you need to use this */ +#ifndef STANDALONE + ozz = pbx_builtin_getvar_helper(p->owner, "FEATDMF_OZZ"); + if (!ozz) + ozz = analog_defaultozz; + cic = pbx_builtin_getvar_helper(p->owner, "FEATDMF_CIC"); + if (!cic) + cic = analog_defaultcic; +#endif + if (!ozz || !cic) { + ast_log(LOG_WARNING, "Unable to dial channel of type feature group D MF tandem access without CIC or OZZ set\n"); + return -1; + } + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s%s#", ozz, cic); + snprintf(p->finaldial, sizeof(p->finaldial), "M*%s#", c); + p->whichwink = 0; + } + break; + case ANALOG_SIG_E911: + ast_copy_string(p->dop.dialstr, "M*911#", sizeof(p->dop.dialstr)); + break; + case ANALOG_SIG_FGC_CAMA: + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%s", c); + break; + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c); + break; + default: + if (p->pulse) + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%sw", c); + else + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c); + break; + } + + if (p->echotraining && (strlen(p->dop.dialstr) > 4)) { + memset(p->echorest, 'w', sizeof(p->echorest) - 1); + strcpy(p->echorest + (p->echotraining / 400) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2); + p->echorest[sizeof(p->echorest) - 1] = '\0'; + p->echobreak = 1; + p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0'; + } else + p->echobreak = 0; + if (!res) { + if (analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop)) { + int saveerr = errno; + + analog_on_hook(p); + ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr)); + return -1; + } + } else + ast_debug(1, "Deferring dialing...\n"); + p->dialing = 1; + if (ast_strlen_zero(c)) + p->dialednone = 1; + ast_setstate(ast, AST_STATE_DIALING); + break; + default: + ast_debug(1, "not yet implemented\n"); + return -1; + } + return 0; +} + +int analog_hangup(struct analog_pvt *p, struct ast_channel *ast) +{ + int res; + int index, x; + + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + if (!ast->tech_pvt) { + ast_log(LOG_WARNING, "Asked to hangup channel not connected\n"); + return 0; + } + + index = analog_get_index(ast, p, 1); + + x = 0; + if (p->origcid_num) { + ast_copy_string(p->cid_num, p->origcid_num, sizeof(p->cid_num)); + free(p->origcid_num); + p->origcid_num = NULL; + } + if (p->origcid_name) { + ast_copy_string(p->cid_name, p->origcid_name, sizeof(p->cid_name)); + free(p->origcid_name); + p->origcid_name = NULL; + } + + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_DTMF); + + ast_debug(1, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n", + p->channel, index, p->subs[ANALOG_SUB_REAL].allocd, p->subs[ANALOG_SUB_CALLWAIT].allocd, p->subs[ANALOG_SUB_THREEWAY].allocd); + if (index > -1) { + /* Real channel, do some fixup */ + p->subs[index].owner = NULL; + p->subs[index].needcallerid = 0; + p->polarity = POLARITY_IDLE; + if (index == ANALOG_SUB_REAL) { + if (p->subs[ANALOG_SUB_CALLWAIT].allocd && p->subs[ANALOG_SUB_THREEWAY].allocd) { + ast_debug(1, "Normal call hung up with both three way call and a call waiting call in place?\n"); + if (p->subs[ANALOG_SUB_CALLWAIT].inthreeway) { + /* We had flipped over to answer a callwait and now it's gone */ + ast_debug(1, "We were flipped over to the callwait, moving back and unowning.\n"); + /* Move to the call-wait, but un-own us until they flip back. */ + analog_swap_subs(p, ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL); + analog_unalloc_sub(p, ANALOG_SUB_CALLWAIT); + p->owner = NULL; + } else { + /* The three way hung up, but we still have a call wait */ + ast_debug(1, "We were in the threeway and have a callwait still. Ditching the threeway.\n"); + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + if (p->subs[ANALOG_SUB_REAL].inthreeway) { + /* This was part of a three way call. Immediately make way for + another call */ + ast_debug(1, "Call was complete, setting owner to former third call\n"); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + } else { + /* This call hasn't been completed yet... Set owner to NULL */ + ast_debug(1, "Call was incomplete, setting owner to NULL\n"); + p->owner = NULL; + } + p->subs[ANALOG_SUB_REAL].inthreeway = 0; + } + } else if (p->subs[ANALOG_SUB_CALLWAIT].allocd) { + /* Move to the call-wait and switch back to them. */ + analog_swap_subs(p, ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL); + analog_unalloc_sub(p, ANALOG_SUB_CALLWAIT); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + if (p->owner->_state != AST_STATE_UP) + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_ANSWER); + if (ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)) + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_UNHOLD); + } else if (p->subs[ANALOG_SUB_THREEWAY].allocd) { + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + if (p->subs[ANALOG_SUB_REAL].inthreeway) { + /* This was part of a three way call. Immediately make way for + another call */ + ast_debug(1, "Call was complete, setting owner to former third call\n"); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + } else { + /* This call hasn't been completed yet... Set owner to NULL */ + ast_debug(1, "Call was incomplete, setting owner to NULL\n"); + p->owner = NULL; + } + p->subs[ANALOG_SUB_REAL].inthreeway = 0; + } + } else if (index == ANALOG_SUB_CALLWAIT) { + /* Ditch the holding callwait call, and immediately make it availabe */ + if (p->subs[ANALOG_SUB_CALLWAIT].inthreeway) { + /* This is actually part of a three way, placed on hold. Place the third part + on music on hold now */ + if (p->subs[ANALOG_SUB_THREEWAY].owner && ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)) { + ast_queue_control_data(p->subs[ANALOG_SUB_THREEWAY].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + p->subs[ANALOG_SUB_THREEWAY].inthreeway = 0; + /* Make it the call wait now */ + analog_swap_subs(p, ANALOG_SUB_CALLWAIT, ANALOG_SUB_THREEWAY); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + } else + analog_unalloc_sub(p, ANALOG_SUB_CALLWAIT); + } else if (index == ANALOG_SUB_THREEWAY) { + if (p->subs[ANALOG_SUB_CALLWAIT].inthreeway) { + /* The other party of the three way call is currently in a call-wait state. + Start music on hold for them, and take the main guy out of the third call */ + if (p->subs[ANALOG_SUB_CALLWAIT].owner && ast_bridged_channel(p->subs[ANALOG_SUB_CALLWAIT].owner)) { + ast_queue_control_data(p->subs[ANALOG_SUB_CALLWAIT].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + p->subs[ANALOG_SUB_CALLWAIT].inthreeway = 0; + } + p->subs[ANALOG_SUB_REAL].inthreeway = 0; + /* If this was part of a three way call index, let us make + another three way call */ + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + } else { + /* This wasn't any sort of call, but how are we an index? */ + ast_log(LOG_WARNING, "Index found but not any type of call?\n"); + } + } + + if (!p->subs[ANALOG_SUB_REAL].owner && !p->subs[ANALOG_SUB_CALLWAIT].owner && !p->subs[ANALOG_SUB_THREEWAY].owner) { + p->owner = NULL; +#if 0 + p->ringt = 0; +#endif +#if 0 /* Since we set it in _call */ + p->cidrings = 1; +#endif + p->outgoing = 0; + + /* Perform low level hangup if no owner left */ + res = analog_on_hook(p); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name); + } + switch (p->sig) { + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOKS: + /* If they're off hook, try playing congestion */ + if (analog_is_off_hook(p)) + analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + else + analog_play_tone(p, ANALOG_SUB_REAL, -1); + break; + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSKS: + /* Make sure we're not made available for at least two seconds assuming + we were actually used for an inbound or outbound call. */ + if (ast->_state != AST_STATE_RESERVED) { + time(&p->guardtime); + p->guardtime += 2; + } + break; + default: + analog_play_tone(p, ANALOG_SUB_REAL, -1); + } + + + analog_set_echocanceller(p, 0); + + x = 0; + ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0); + ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0); + p->callwaitcas = 0; + p->callwaiting = p->permcallwaiting; + p->hidecallerid = p->permhidecallerid; + p->dialing = 0; + analog_update_conf(p); + analog_all_subchannels_hungup(p); + } + + analog_stop_callwait(p); + ast->tech_pvt = NULL; + + if (option_verbose > 2) { + ast_verbose(VERBOSE_PREFIX_3 "Hanging up on '%s'\n", ast->name); + } + + return 0; +} + +int analog_answer(struct analog_pvt *p, struct ast_channel *ast) +{ + int res = 0; + int index; + int oldstate = ast->_state; + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + ast_setstate(ast, AST_STATE_UP); + index = analog_get_index(ast, p, 1); + if (index < 0) + index = ANALOG_SUB_REAL; + switch (p->sig) { + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: +#if 0 + p->ringt = 0; +#endif + /* Fall through */ + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SF: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + /* Pick up the line */ + ast_debug(1, "Took %s off hook\n", ast->name); + if (p->hanguponpolarityswitch) { + gettimeofday(&p->polaritydelaytv, NULL); + } + res = analog_off_hook(p); + analog_play_tone(p, index, -1); + p->dialing = 0; + if ((index == ANALOG_SUB_REAL) && p->subs[ANALOG_SUB_THREEWAY].inthreeway) { + if (oldstate == AST_STATE_RINGING) { + ast_debug(1, "Finally swapping real and threeway\n"); + analog_play_tone(p, ANALOG_SUB_THREEWAY, -1); + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + } + } + if ((p->sig == ANALOG_SIG_FXSLS) || (p->sig == ANALOG_SIG_FXSKS) || (p->sig == ANALOG_SIG_FXSGS)) { + analog_set_echocanceller(p, 1); + analog_train_echocanceller(p); + } + break; + default: + ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel); + res = -1; + } + ast_setstate(ast, AST_STATE_UP); + return res; +} + +static int analog_handles_digit(struct ast_frame *f) +{ + char subclass = toupper(f->subclass); + + switch (subclass) { + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '9': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + return 1; + default: + return 0; + } +} + +void analog_handle_dtmfup(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub index, struct ast_frame **dest) +{ + struct ast_frame *f = *dest; + + if (p->callwaitcas) { + if ((f->subclass == 'A') || (f->subclass == 'D')) { + ast_log(LOG_ERROR, "Got some DTMF, but it's for the CAS\n"); + p->cid.cid_name = p->callwait_name; + p->cid.cid_num = p->callwait_num; + analog_send_callerid(p, 1, &p->cid); + } + if (analog_handles_digit(f)) + p->callwaitcas = 0; + p->subs[index].f.frametype = AST_FRAME_NULL; + p->subs[index].f.subclass = 0; + *dest = &p->subs[index].f; + } else { + analog_cb_handle_dtmfup(p, ast, index, dest); + } +} + +static int analog_my_getsigstr(struct ast_channel *chan, char *str, const char *term, int ms) +{ + char c; + + *str = 0; /* start with empty output buffer */ + for (;;) + { + /* Wait for the first digit (up to specified ms). */ + c = ast_waitfordigit(chan, ms); + /* if timeout, hangup or error, return as such */ + if (c < 1) + return c; + *str++ = c; + *str = 0; + if (strchr(term, c)) + return 1; + } +} + +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); + return 0; + } + else + return -1; +} + +static int analog_increase_ss_count(struct analog_pvt *p) +{ + if (p->calls->increase_ss_count) { + p->calls->increase_ss_count(); + return 0; + } else + return -1; +} + +static int analog_decrease_ss_count(struct analog_pvt *p) +{ + if (p->calls->decrease_ss_count) { + p->calls->decrease_ss_count(); + return 0; + } else + return -1; +} + +#define ANALOG_NEED_MFDETECT(p) (((p)->sig == ANALOG_SIG_FEATDMF) || ((p)->sig == ANALOG_SIG_FEATDMF_TA) || ((p)->sig == ANALOG_SIG_E911) || ((p)->sig == ANALOG_SIG_FGC_CAMA) || ((p)->sig == ANALOG_SIG_FGC_CAMAMF) || ((p)->sig == ANALOG_SIG_FEATB)) + +/* Note by jpeeler: This function has a rather large section of code ifdefed + * away. I'd like to leave the code there until more testing is done and I + * know for sure that nothing got left out. The plan is at the latest for this + * comment and code below to be removed shortly after the merging of sig_pri. + */ +static void *__analog_ss_thread(void *data) +{ + struct analog_pvt *p = data; + struct ast_channel *chan = p->ss_astchan; + char exten[AST_MAX_EXTENSION] = ""; + char exten2[AST_MAX_EXTENSION] = ""; + char dtmfcid[300]; + char dtmfbuf[300]; + char namebuf[ANALOG_MAX_CID]; + char numbuf[ANALOG_MAX_CID]; + struct callerid_state *cs = NULL; + char *name = NULL, *number = NULL; + int flags; +#if 0 + unsigned char buf[256]; + int distMatches; + int curRingData[3]; + int receivedRingT; + int samples = 0; + int counter1; + int counter; + int i; +#endif + int timeout; + int getforward = 0; + char *s1, *s2; + int len = 0; + int res; + int index; + + analog_increase_ss_count(p); + + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + + /* in the bizarre case where the channel has become a zombie before we + even get started here, abort safely + */ + if (!p) { + ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name); + ast_hangup(chan); + goto quit; + } + + ast_verb(3, "Starting simple switch on '%s'\n", chan->name); + index = analog_get_index(chan, p, 1); + if (index < 0) { + ast_log(LOG_WARNING, "Huh?\n"); + ast_hangup(chan); + goto quit; + } + analog_dsp_reset_and_flush_digits(p); + switch (p->sig) { + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + case ANALOG_SIG_SFWINK: + if (analog_wink(p, index)) + goto quit; + /* Fall through */ + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_SF: + case ANALOG_SIG_FGC_CAMA: + res = analog_play_tone(p, index, -1); + + analog_dsp_reset_and_flush_digits(p); + + if (ANALOG_NEED_MFDETECT(p)) { + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_MF); + } else + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_DTMF); + + memset(dtmfbuf, 0, sizeof(dtmfbuf)); + /* Wait for the first digit only if immediate=no */ + if (!p->immediate) + /* Wait for the first digit (up to 5 seconds). */ + res = ast_waitfordigit(chan, 5000); + else + res = 0; + if (res > 0) { + /* save first char */ + dtmfbuf[0] = res; + switch (p->sig) { + case ANALOG_SIG_FEATD: + case ANALOG_SIG_SF_FEATD: + res = analog_my_getsigstr(chan, dtmfbuf + 1, "*", 3000); + if (res > 0) + res = analog_my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000); + if (res < 1) + analog_dsp_reset_and_flush_digits(p); + break; + case ANALOG_SIG_FEATDMF_TA: + res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000); + if (res < 1) + analog_dsp_reset_and_flush_digits(p); + if (analog_wink(p, index)) goto quit; + dtmfbuf[0] = 0; + /* Wait for the first digit (up to 5 seconds). */ + res = ast_waitfordigit(chan, 5000); + if (res <= 0) break; + dtmfbuf[0] = res; + /* fall through intentionally */ + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_SF_FEATDMF: + res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000); + /* if international caca, do it again to get real ANO */ + if ((p->sig == ANALOG_SIG_FEATDMF) && (dtmfbuf[1] != '0') && (strlen(dtmfbuf) != 14)) + { + if (analog_wink(p, index)) goto quit; + dtmfbuf[0] = 0; + /* Wait for the first digit (up to 5 seconds). */ + res = ast_waitfordigit(chan, 5000); + if (res <= 0) break; + dtmfbuf[0] = res; + res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000); + } + if (res > 0) { + /* if E911, take off hook */ + if (p->sig == ANALOG_SIG_E911) + analog_off_hook(p); + res = analog_my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "#", 3000); + } + if (res < 1) + analog_dsp_reset_and_flush_digits(p); + break; + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SF_FEATB: + res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000); + if (res < 1) + analog_dsp_reset_and_flush_digits(p); + break; + case ANALOG_SIG_EMWINK: + /* if we received a '*', we are actually receiving Feature Group D + dial syntax, so use that mode; otherwise, fall through to normal + mode + */ + if (res == '*') { + res = analog_my_getsigstr(chan, dtmfbuf + 1, "*", 3000); + if (res > 0) + res = analog_my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000); + if (res < 1) + analog_dsp_reset_and_flush_digits(p); + break; + } + default: + /* If we got the first digit, get the rest */ + len = 1; + dtmfbuf[len] = '\0'; + while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, dtmfbuf, 1, p->cid_num)) { + if (ast_exists_extension(chan, chan->context, dtmfbuf, 1, p->cid_num)) { + timeout = analog_matchdigittimeout; + } else { + timeout = analog_gendigittimeout; + } + res = ast_waitfordigit(chan, timeout); + if (res < 0) { + ast_debug(1, "waitfordigit returned < 0...\n"); + ast_hangup(chan); + goto quit; + } else if (res) { + dtmfbuf[len++] = res; + dtmfbuf[len] = '\0'; + } else { + break; + } + } + break; + } + } + if (res == -1) { + ast_log(LOG_WARNING, "getdtmf on channel %d: %s\n", p->channel, strerror(errno)); + ast_hangup(chan); + goto quit; + } else if (res < 0) { + ast_debug(1, "Got hung up before digits finished\n"); + ast_hangup(chan); + goto quit; + } + + if (p->sig == ANALOG_SIG_FGC_CAMA) { + char anibuf[100]; + + if (ast_safe_sleep(chan,1000) == -1) { + ast_hangup(chan); + goto quit; + } + analog_off_hook(p); + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_MF); + res = analog_my_getsigstr(chan, anibuf, "#", 10000); + if ((res > 0) && (strlen(anibuf) > 2)) { + if (anibuf[strlen(anibuf) - 1] == '#') + anibuf[strlen(anibuf) - 1] = 0; + ast_set_callerid(chan, anibuf + 2, NULL, anibuf + 2); + } + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_DTMF); + } + + ast_copy_string(exten, dtmfbuf, sizeof(exten)); + if (ast_strlen_zero(exten)) + ast_copy_string(exten, "s", sizeof(exten)); + if (p->sig == ANALOG_SIG_FEATD || p->sig == ANALOG_SIG_EMWINK) { + /* Look for Feature Group D on all E&M Wink and Feature Group D trunks */ + if (exten[0] == '*') { + char *stringp=NULL; + ast_copy_string(exten2, exten, sizeof(exten2)); + /* Parse out extension and callerid */ + stringp=exten2 +1; + s1 = strsep(&stringp, "*"); + s2 = strsep(&stringp, "*"); + if (s2) { + if (!ast_strlen_zero(p->cid_num)) + ast_set_callerid(chan, p->cid_num, NULL, p->cid_num); + else + ast_set_callerid(chan, s1, NULL, s1); + ast_copy_string(exten, s2, sizeof(exten)); + } else + ast_copy_string(exten, s1, sizeof(exten)); + } else if (p->sig == ANALOG_SIG_FEATD) + ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel); + } + if ((p->sig == ANALOG_SIG_FEATDMF) || (p->sig == ANALOG_SIG_FEATDMF_TA)) { + if (exten[0] == '*') { + char *stringp=NULL; + ast_copy_string(exten2, exten, sizeof(exten2)); + /* Parse out extension and callerid */ + stringp=exten2 +1; + s1 = strsep(&stringp, "#"); + s2 = strsep(&stringp, "#"); + if (s2) { + if (!ast_strlen_zero(p->cid_num)) + ast_set_callerid(chan, p->cid_num, NULL, p->cid_num); + else + if (*(s1 + 2)) + ast_set_callerid(chan, s1 + 2, NULL, s1 + 2); + ast_copy_string(exten, s2 + 1, sizeof(exten)); + } else + ast_copy_string(exten, s1 + 2, sizeof(exten)); + } else + ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel); + } + if ((p->sig == ANALOG_SIG_E911) || (p->sig == ANALOG_SIG_FGC_CAMAMF)) { + if (exten[0] == '*') { + char *stringp=NULL; + ast_copy_string(exten2, exten, sizeof(exten2)); + /* Parse out extension and callerid */ + stringp=exten2 +1; + s1 = strsep(&stringp, "#"); + s2 = strsep(&stringp, "#"); + if (s2 && (*(s2 + 1) == '0')) { + if (*(s2 + 2)) + ast_set_callerid(chan, s2 + 2, NULL, s2 + 2); + } + if (s1) ast_copy_string(exten, s1, sizeof(exten)); + else ast_copy_string(exten, "911", sizeof(exten)); + } else + ast_log(LOG_WARNING, "Got a non-E911/FGC CAMA input on channel %d. Assuming E&M Wink instead\n", p->channel); + } + if (p->sig == ANALOG_SIG_FEATB) { + if (exten[0] == '*') { + char *stringp=NULL; + ast_copy_string(exten2, exten, sizeof(exten2)); + /* Parse out extension and callerid */ + stringp=exten2 +1; + s1 = strsep(&stringp, "#"); + ast_copy_string(exten, exten2 + 1, sizeof(exten)); + } else + ast_log(LOG_WARNING, "Got a non-Feature Group B input on channel %d. Assuming E&M Wink instead\n", p->channel); + } + if ((p->sig == ANALOG_SIG_FEATDMF) || (p->sig == ANALOG_SIG_FEATDMF_TA)) { + analog_wink(p, index); + /* some switches require a minimum guard time between + the last FGD wink and something that answers + immediately. This ensures it */ + if (ast_safe_sleep(chan,100)) goto quit; + } + analog_set_echocanceller(p, 1); + + analog_dsp_set_digitmode(p, ANALOG_DIGITMODE_DTMF); + + if (ast_exists_extension(chan, chan->context, exten, 1, chan->cid.cid_num)) { + ast_copy_string(chan->exten, exten, sizeof(chan->exten)); + analog_dsp_reset_and_flush_digits(p); + res = ast_pbx_run(chan); + if (res) { + ast_log(LOG_WARNING, "PBX exited non-zero\n"); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + } + goto quit; + } else { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_2 "Unknown extension '%s' in context '%s' requested\n", exten, chan->context); + sleep(2); + res = analog_play_tone(p, index, ANALOG_TONE_INFO); + if (res < 0) + ast_log(LOG_WARNING, "Unable to start special tone on %d\n", p->channel); + else + sleep(1); + res = ast_streamfile(chan, "ss-noservice", chan->language); + if (res >= 0) + ast_waitstream(chan, ""); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + ast_hangup(chan); + goto quit; + } + break; + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + /* Read the first digit */ + timeout = analog_firstdigittimeout; + /* If starting a threeway call, never timeout on the first digit so someone + can use flash-hook as a "hold" feature */ + if (p->subs[ANALOG_SUB_THREEWAY].owner) + timeout = 999999; + while (len < AST_MAX_EXTENSION-1) { + /* Read digit unless it's supposed to be immediate, in which case the + only answer is 's' */ + if (p->immediate) + res = 's'; + else + res = ast_waitfordigit(chan, timeout); + timeout = 0; + if (res < 0) { + ast_debug(1, "waitfordigit returned < 0...\n"); + res = analog_play_tone(p, index, -1); + ast_hangup(chan); + goto quit; + } else if (res) { + exten[len++]=res; + exten[len] = '\0'; + } + if (!ast_ignore_pattern(chan->context, exten)) + analog_play_tone(p, index, -1); + else + analog_play_tone(p, index, ANALOG_TONE_DIALTONE); + if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num) && strcmp(exten, ast_parking_ext())) { + if (!res || !ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) { + if (getforward) { + /* Record this as the forwarding extension */ + ast_copy_string(p->call_forward, exten, sizeof(p->call_forward)); + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Setting call forward to '%s' on channel %d\n", p->call_forward, p->channel); + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + if (res) + break; + usleep(500000); + res = analog_play_tone(p, index, -1); + sleep(1); + memset(exten, 0, sizeof(exten)); + res = analog_play_tone(p, index, ANALOG_TONE_DIALTONE); + len = 0; + getforward = 0; + } else { + res = analog_play_tone(p, index, -1); + ast_copy_string(chan->exten, exten, sizeof(chan->exten)); + if (!ast_strlen_zero(p->cid_num)) { + if (!p->hidecallerid) + ast_set_callerid(chan, p->cid_num, NULL, p->cid_num); + else + ast_set_callerid(chan, NULL, NULL, p->cid_num); + } + if (!ast_strlen_zero(p->cid_name)) { + if (!p->hidecallerid) + ast_set_callerid(chan, NULL, p->cid_name, NULL); + } + ast_setstate(chan, AST_STATE_RING); + analog_set_echocanceller(p, 1); + res = ast_pbx_run(chan); + if (res) { + ast_log(LOG_WARNING, "PBX exited non-zero\n"); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + } + goto quit; + } + } else { + /* It's a match, but they just typed a digit, and there is an ambiguous match, + so just set the timeout to analog_matchdigittimeout and wait some more */ + timeout = analog_matchdigittimeout; + } + } else if (res == 0) { + ast_debug(1, "not enough digits (and no ambiguous match)...\n"); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + analog_wait_event(p); + ast_hangup(chan); + goto quit; + } else if (p->callwaiting && !strcmp(exten, "*70")) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Disabling call waiting on %s\n", chan->name); + /* Disable call waiting if enabled */ + p->callwaiting = 0; + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + if (res) { + ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", + chan->name, strerror(errno)); + } + len = 0; + memset(exten, 0, sizeof(exten)); + timeout = analog_firstdigittimeout; + + } else if (!strcmp(exten,ast_pickup_ext())) { + /* Scan all channels and see if there are any + * ringing channels that have call groups + * that equal this channels pickup group + */ + if (index == ANALOG_SUB_REAL) { + /* Switch us from Third call to Call Wait */ + if (p->subs[ANALOG_SUB_THREEWAY].owner) { + /* If you make a threeway call and the *8# a call, it should actually + look like a callwait */ + analog_alloc_sub(p, ANALOG_SUB_CALLWAIT); + analog_swap_subs(p, ANALOG_SUB_CALLWAIT, ANALOG_SUB_THREEWAY); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + } + analog_set_echocanceller(p, 1); + if (ast_pickup_call(chan)) { + ast_debug(1, "No call pickup possible...\n"); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + analog_wait_event(p); + } + ast_hangup(chan); + goto quit; + } else { + ast_log(LOG_WARNING, "Huh? Got *8# on call not on real\n"); + ast_hangup(chan); + goto quit; + } + } else if (!p->hidecallerid && !strcmp(exten, "*67")) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Disabling Caller*ID on %s\n", chan->name); + /* Disable Caller*ID if enabled */ + p->hidecallerid = 1; + if (chan->cid.cid_num) + free(chan->cid.cid_num); + chan->cid.cid_num = NULL; + if (chan->cid.cid_name) + free(chan->cid.cid_name); + chan->cid.cid_name = NULL; + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + if (res) { + ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", + chan->name, strerror(errno)); + } + len = 0; + memset(exten, 0, sizeof(exten)); + timeout = analog_firstdigittimeout; + } else if (p->callreturn && !strcmp(exten, "*69")) { + res = 0; + if (!ast_strlen_zero(p->lastcid_num)) { + res = ast_say_digit_str(chan, p->lastcid_num, "", chan->language); + } + if (!res) + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + break; + } else if (!strcmp(exten, "*78")) { + /* Do not disturb */ + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Enabled DND on channel %d\n", p->channel); +#if 0 + manager_event(EVENT_FLAG_SYSTEM, "DNDState", + "Channel: %s/%d\r\n" + "Status: enabled\r\n", dahdi_chan_name, p->channel); +#endif + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + p->dnd = 1; + getforward = 0; + memset(exten, 0, sizeof(exten)); + len = 0; + } else if (!strcmp(exten, "*79")) { + /* Do not disturb */ + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Disabled DND on channel %d\n", p->channel); +#if 0 + manager_event(EVENT_FLAG_SYSTEM, "DNDState", + "Channel: %s/%d\r\n" + "Status: disabled\r\n", dahdi_chan_name, p->channel); +#endif + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + p->dnd = 0; + getforward = 0; + memset(exten, 0, sizeof(exten)); + len = 0; + } else if (p->cancallforward && !strcmp(exten, "*72")) { + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + getforward = 1; + memset(exten, 0, sizeof(exten)); + len = 0; + } else if (p->cancallforward && !strcmp(exten, "*73")) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Cancelling call forwarding on channel %d\n", p->channel); + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + memset(p->call_forward, 0, sizeof(p->call_forward)); + getforward = 0; + memset(exten, 0, sizeof(exten)); + len = 0; + } else if ((p->transfer || p->canpark) && !strcmp(exten, ast_parking_ext()) && + p->subs[ANALOG_SUB_THREEWAY].owner && + ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)) { + /* This is a three way call, the main call being a real channel, + and we're parking the first call. */ + ast_masq_park_call(ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner), chan, 0, NULL); + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Parking call to '%s'\n", chan->name); + break; + } else if (!ast_strlen_zero(p->lastcid_num) && !strcmp(exten, "*60")) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Blacklisting number %s\n", p->lastcid_num); + res = ast_db_put("blacklist", p->lastcid_num, "1"); + if (!res) { + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + memset(exten, 0, sizeof(exten)); + len = 0; + } + } else if (p->hidecallerid && !strcmp(exten, "*82")) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Enabling Caller*ID on %s\n", chan->name); + /* Enable Caller*ID if enabled */ + p->hidecallerid = 0; + if (chan->cid.cid_num) + free(chan->cid.cid_num); + chan->cid.cid_num = NULL; + if (chan->cid.cid_name) + free(chan->cid.cid_name); + chan->cid.cid_name = NULL; + ast_set_callerid(chan, p->cid_num, p->cid_name, NULL); + res = analog_play_tone(p, index, ANALOG_TONE_DIALRECALL); + if (res) { + ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", + chan->name, strerror(errno)); + } + len = 0; + memset(exten, 0, sizeof(exten)); + timeout = analog_firstdigittimeout; + } else if (!strcmp(exten, "*0")) { +#ifdef XXX + struct ast_channel *nbridge = p->subs[ANALOG_SUB_THREEWAY].owner; + struct dahdi_pvt *pbridge = NULL; + /* set up the private struct of the bridged one, if any */ + if (nbridge && ast_bridged_channel(nbridge)) + pbridge = ast_bridged_channel(nbridge)->tech_pvt; + if (nbridge && pbridge && + (nbridge->tech == chan_tech) && + (ast_bridged_channel(nbridge)->tech == chan_tech) && + ISTRUNK(pbridge)) { + int func = DAHDI_FLASH; + /* Clear out the dial buffer */ + p->dop.dialstr[0] = '\0'; + /* flash hookswitch */ + if ((ioctl(pbridge->subs[ANALOG_SUB_REAL].dfd,DAHDI_HOOK,&func) == -1) && (errno != EINPROGRESS)) { + ast_log(LOG_WARNING, "Unable to flash external trunk on channel %s: %s\n", + nbridge->name, strerror(errno)); + } + analog_swap_subs(p, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + if (ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)) + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_UNHOLD); + ast_hangup(chan); + goto quit; + } else { + analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + analog_wait_event(p); + analog_play_tone(p, index, -1); + analog_swap_subs(p, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY); + analog_unalloc_sub(p, ANALOG_SUB_THREEWAY); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + ast_hangup(chan); + goto quit; + } +#endif + } else if (!ast_canmatch_extension(chan, chan->context, exten, 1, chan->cid.cid_num) && + ((exten[0] != '*') || (strlen(exten) > 2))) { + ast_debug(1, "Can't match %s from '%s' in context %s\n", exten, chan->cid.cid_num ? chan->cid.cid_num : "<Unknown Caller>", chan->context); + break; + } + if (!timeout) + timeout = analog_gendigittimeout; + if (len && !ast_ignore_pattern(chan->context, exten)) + analog_play_tone(p, index, -1); + } + break; + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: + + /* If we want caller id, we're in a prering state due to a polarity reversal + * and we're set to use a polarity reversal to trigger the start of caller id, + * grab the caller id and wait for ringing to start... */ + if (p->use_callerid && (chan->_state == AST_STATE_PRERING && (p->cid_start == ANALOG_CID_START_POLARITY || p->cid_start == ANALOG_CID_START_POLARITY_IN))) { + /* If set to use DTMF CID signalling, listen for DTMF */ + if (p->cid_signalling == CID_SIG_DTMF) { + int i = 0; + cs = NULL; + ast_debug(1, "Receiving DTMF cid on " + "channel %s\n", chan->name); +#if 0 + dahdi_setlinear(p->subs[index].dfd, 0); +#endif + res = 2000; + for (;;) { + struct ast_frame *f; + res = ast_waitfor(chan, res); + if (res <= 0) { + ast_log(LOG_WARNING, "DTMFCID timed out waiting for ring. " + "Exiting simple switch\n"); + ast_hangup(chan); + goto quit; + } + f = ast_read(chan); + if (!f) + break; + if (f->frametype == AST_FRAME_DTMF) { + dtmfbuf[i++] = f->subclass; + ast_debug(1, "CID got digit '%c'\n", f->subclass); + res = 2000; + } + ast_frfree(f); + if (chan->_state == AST_STATE_RING || + chan->_state == AST_STATE_RINGING) + break; /* Got ring */ + } + dtmfbuf[i] = '\0'; +#if 0 + dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear); +#endif + /* Got cid and ring. */ + ast_debug(1, "CID got string '%s'\n", dtmfbuf); + callerid_get_dtmf(dtmfbuf, dtmfcid, &flags); + ast_debug(1, "CID is '%s', flags %d\n", + dtmfcid, flags); + /* If first byte is NULL, we have no cid */ + if (!ast_strlen_zero(dtmfcid)) + number = dtmfcid; + else + number = NULL; +#if 0 + /* If set to use V23 Signalling, launch our FSK gubbins and listen for it */ + } else if ((p->cid_signalling == CID_SIG_V23) || (p->cid_signalling == CID_SIG_V23_JP)) { + cs = callerid_new(p->cid_signalling); + if (cs) { + samples = 0; +#if 1 + bump_gains(p); +#endif + /* Take out of linear mode for Caller*ID processing */ + dahdi_setlinear(p->subs[index].dfd, 0); + + /* First we wait and listen for the Caller*ID */ + for (;;) { + i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT; + if ((res = ioctl(p->subs[index].dfd, DAHDI_IOMUX, &i))) { + ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno)); + callerid_free(cs); + ast_hangup(chan); + goto quit; + } + if (i & DAHDI_IOMUX_SIGEVENT) { + res = dahdi_get_event(p->subs[index].dfd); + ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res)); + + if (p->cid_signalling == CID_SIG_V23_JP) { +#ifdef DAHDI_EVENT_RINGBEGIN + if (res == ANALOG_EVENT_RINGBEGIN) { + res = analog_off_hook(p); + usleep(1); + } +#endif + } else { + res = 0; + break; + } + } else if (i & DAHDI_IOMUX_READ) { + res = read(p->subs[index].dfd, buf, sizeof(buf)); + if (res < 0) { + if (errno != ELAST) { + ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno)); + callerid_free(cs); + ast_hangup(chan); + goto quit; + } + break; + } + samples += res; + + if (p->cid_signalling == CID_SIG_V23_JP) { + res = callerid_feed_jp(cs, buf, res, AST_LAW(p)); + } else { + res = callerid_feed(cs, buf, res, AST_LAW(p)); + } + + if (res < 0) { + ast_log(LOG_WARNING, "CallerID feed failed on channel '%s'\n", chan->name); + break; + } else if (res) + break; + else if (samples > (8000 * 10)) + break; + } + } + if (res == 1) { + callerid_get(cs, &name, &number, &flags); + ast_log(LOG_NOTICE, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags); + } + + if (p->cid_signalling == CID_SIG_V23_JP) { + res = analog_on_hook(p); + usleep(1); + res = 4000; + } else { + + /* Finished with Caller*ID, now wait for a ring to make sure there really is a call coming */ + res = 2000; + } + + for (;;) { + struct ast_frame *f; + res = ast_waitfor(chan, res); + if (res <= 0) { + ast_log(LOG_WARNING, "CID timed out waiting for ring. " + "Exiting simple switch\n"); + ast_hangup(chan); + goto quit; + } + if (!(f = ast_read(chan))) { + ast_log(LOG_WARNING, "Hangup received waiting for ring. Exiting simple switch\n"); + ast_hangup(chan); + goto quit; + } + ast_frfree(f); + if (chan->_state == AST_STATE_RING || + chan->_state == AST_STATE_RINGING) + break; /* Got ring */ + } + + /* Restore linear mode (if appropriate) for Caller*ID processing */ + dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear); +#if 1 + restore_gains(p); +#endif + } else + ast_log(LOG_WARNING, "Unable to get caller ID space\n"); +#endif + } else { + ast_log(LOG_WARNING, "Channel %s in prering " + "state, but I have nothing to do. " + "Terminating simple switch, should be " + "restarted by the actual ring.\n", + chan->name); + ast_hangup(chan); + goto quit; + } + } else if (p->use_callerid && p->cid_start == ANALOG_CID_START_RING) { + int timeout = 10000; /* Ten seconds */ + struct timeval start = ast_tvnow(); + enum analog_event ev; + + namebuf[0] = 0; + numbuf[0] = 0; + + if (!analog_start_cid_detect(p, p->cid_signalling)) { + while (1) { + res = analog_get_callerid(p, namebuf, numbuf, &ev, timeout - ast_tvdiff_ms(ast_tvnow(), start)); + + if (res == 0) { + break; + } + + if (res == 1) { + if (ev == ANALOG_EVENT_POLARITY && p->hanguponpolarityswitch && p->polarity == POLARITY_REV) { + ast_debug(1, "Hanging up due to polarity reversal on channel %d while detecting callerid\n", p->channel); + p->polarity = POLARITY_IDLE; + ast_hangup(chan); + goto quit; + } else if (ev != ANALOG_EVENT_NONE) { + break; + } + } + + if (ast_tvdiff_ms(ast_tvnow(), start) > timeout) + break; + + } + name = namebuf; + number = numbuf; + + analog_stop_cid_detect(p); + +#if 0 + /* XXX */ + if (strcmp(p->context,p->defcontext) != 0) { + ast_copy_string(p->context, p->defcontext, sizeof(p->context)); + ast_copy_string(chan->context,p->defcontext,sizeof(chan->context)); + } + + analog_get_callerid(p, name, number); + /* FSK Bell202 callerID */ + cs = callerid_new(p->cid_signalling); + if (cs) { +#if 1 + bump_gains(p); +#endif + samples = 0; + len = 0; + distMatches = 0; + /* Clear the current ring data array so we dont have old data in it. */ + for (receivedRingT = 0; receivedRingT < (sizeof(curRingData) / sizeof(curRingData[0])); receivedRingT++) + curRingData[receivedRingT] = 0; + receivedRingT = 0; + counter = 0; + counter1 = 0; + /* Check to see if context is what it should be, if not set to be. */ + + /* Take out of linear mode for Caller*ID processing */ + dahdi_setlinear(p->subs[index].dfd, 0); + for (;;) { + i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT; + if ((res = ioctl(p->subs[index].dfd, DAHDI_IOMUX, &i))) { + ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno)); + callerid_free(cs); + ast_hangup(chan); + goto quit; + } + if (i & DAHDI_IOMUX_SIGEVENT) { + res = dahdi_get_event(p->subs[index].dfd); + ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res)); + /* If we get a PR event, they hung up while processing calerid */ + if ( res == ANALOG_EVENT_POLARITY && p->hanguponpolarityswitch && p->polarity == POLARITY_REV) { + ast_debug(1, "Hanging up due to polarity reversal on channel %d while detecting callerid\n", p->channel); + p->polarity = POLARITY_IDLE; + callerid_free(cs); + ast_hangup(chan); + goto quit; + } + res = 0; + /* Let us detect callerid when the telco uses distinctive ring */ + + curRingData[receivedRingT] = p->ringt; + + if (p->ringt < p->ringt_base/2) + break; + /* Increment the ringT counter so we can match it against + values in chan_dahdi.conf for distinctive ring */ + if (++receivedRingT == (sizeof(curRingData) / sizeof(curRingData[0]))) + break; + } else if (i & DAHDI_IOMUX_READ) { + res = read(p->subs[index].dfd, buf, sizeof(buf)); + if (res < 0) { + if (errno != ELAST) { + ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno)); + callerid_free(cs); + ast_hangup(chan); + goto quit; + } + break; + } + if (p->ringt) + p->ringt--; + if (p->ringt == 1) { + res = -1; + break; + } + samples += res; + res = callerid_feed(cs, buf, res, AST_LAW(p)); + if (res < 0) { + ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno)); + break; + } else if (res) + break; + else if (samples > (8000 * 10)) + break; + } + } + if (res == 1) { + callerid_get(cs, &name, &number, &flags); + ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags); + } + /* Restore linear mode (if appropriate) for Caller*ID processing */ + dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear); +#if 1 + restore_gains(p); +#endif + if (res < 0) { + ast_log(LOG_WARNING, "CallerID returned with error on channel '%s'\n", chan->name); + } + } else + ast_log(LOG_WARNING, "Unable to get caller ID space\n"); +#endif + } else + ast_log(LOG_WARNING, "Unable to get caller ID space\n"); + } + else + cs = NULL; + + if (number) + ast_shrink_phone_number(number); + ast_set_callerid(chan, number, name, number); + + if (cs) + callerid_free(cs); + + analog_handle_notify_message(chan, p, flags, -1); + + ast_setstate(chan, AST_STATE_RING); + chan->rings = 1; +#if 0 + p->ringt = p->ringt_base; +#endif + res = ast_pbx_run(chan); + if (res) { + ast_hangup(chan); + ast_log(LOG_WARNING, "PBX exited non-zero\n"); + } + goto quit; + default: + ast_log(LOG_WARNING, "Don't know how to handle simple switch with signalling %s on channel %d\n", analog_sigtype_to_str(p->sig), p->channel); + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel); + } + res = analog_play_tone(p, index, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel); + ast_hangup(chan); +quit: + analog_decrease_ss_count(p); + return NULL; +} + +int analog_ss_thread_start(struct analog_pvt *p, struct ast_channel *chan) +{ + pthread_t threadid; + return ast_pthread_create_detached(&threadid, NULL, __analog_ss_thread, chan); +} + +static struct ast_frame *__analog_handle_event(struct analog_pvt *p, struct ast_channel *ast) +{ + int res, x; + int mysig; + enum analog_sub index; + char *c; + pthread_t threadid; + pthread_attr_t attr; + struct ast_channel *chan; + struct ast_frame *f; + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + + index = analog_get_index(ast, p, 0); + mysig = p->sig; + if (p->outsigmod > -1) + mysig = p->outsigmod; + p->subs[index].f.frametype = AST_FRAME_NULL; + p->subs[index].f.subclass = 0; + p->subs[index].f.datalen = 0; + p->subs[index].f.samples = 0; + p->subs[index].f.mallocd = 0; + p->subs[index].f.offset = 0; + p->subs[index].f.src = "dahdi_handle_event"; + p->subs[index].f.data.ptr = NULL; + f = &p->subs[index].f; + + if (index < 0) + return &p->subs[index].f; + + if (index != ANALOG_SUB_REAL) { + ast_log(LOG_ERROR, "We got an event on a non real sub. Fix it!\n"); + } + + res = analog_get_event(p); + + ast_debug(1, "Got event %s(%d) on channel %d (index %d)\n", analog_event2str(res), res, p->channel, index); + + switch (res) { +#ifdef ANALOG_EVENT_EC_DISABLED + case ANALOG_EVENT_EC_DISABLED: + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Channel %d echo canceler disabled due to CED detection\n", p->channel); + p->echocanon = 0; + break; +#endif + case ANALOG_EVENT_PULSE_START: + /* Stop tone if there's a pulse start and the PBX isn't started */ + if (!ast->pbx) + analog_play_tone(p, ANALOG_SUB_REAL, -1); + break; + case ANALOG_EVENT_DIALCOMPLETE: + if (p->inalarm) break; + x = analog_is_dialing(p, index); + if (!x) { /* if not still dialing in driver */ + analog_set_echocanceller(p, 1); + if (p->echobreak) { + analog_train_echocanceller(p); + ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr)); + p->dop.op = ANALOG_DIAL_OP_REPLACE; + analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop); + p->echobreak = 0; + } else { + p->dialing = 0; + if ((mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA) || (mysig == ANALOG_SIG_FGC_CAMAMF)) { + /* if thru with dialing after offhook */ + if (ast->_state == AST_STATE_DIALING_OFFHOOK) { + ast_setstate(ast, AST_STATE_UP); + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_ANSWER; + break; + } else { /* if to state wait for offhook to dial rest */ + /* we now wait for off hook */ + ast_setstate(ast,AST_STATE_DIALING_OFFHOOK); + } + } + if (ast->_state == AST_STATE_DIALING) { + if ((!p->dialednone && ((mysig == ANALOG_SIG_EM) || (mysig == ANALOG_SIG_EM_E1) || (mysig == ANALOG_SIG_EMWINK) || (mysig == ANALOG_SIG_FEATD) || (mysig == ANALOG_SIG_FEATDMF_TA) || (mysig == ANALOG_SIG_FEATDMF) || (mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA) || (mysig == ANALOG_SIG_FGC_CAMAMF) || (mysig == ANALOG_SIG_FEATB) || (mysig == ANALOG_SIG_SF) || (mysig == ANALOG_SIG_SFWINK) || (mysig == ANALOG_SIG_SF_FEATD) || (mysig == ANALOG_SIG_SF_FEATDMF) || (mysig == ANALOG_SIG_SF_FEATB)))) { + ast_setstate(ast, AST_STATE_RINGING); + } else if (!p->answeronpolarityswitch) { + ast_setstate(ast, AST_STATE_UP); + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_ANSWER; + /* If aops=0 and hops=1, this is necessary */ + p->polarity = POLARITY_REV; + } else { + /* Start clean, so we can catch the change to REV polarity when party answers */ + p->polarity = POLARITY_IDLE; + } + } + } + } + break; + case ANALOG_EVENT_ALARM: + p->inalarm = 1; +#if 0 + res = get_alarms(p); + handle_alarms(p, res); +#endif + case ANALOG_EVENT_ONHOOK: + switch (p->sig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + /* Check for some special conditions regarding call waiting */ + if (index == ANALOG_SUB_REAL) { + /* The normal line was hung up */ + if (p->subs[ANALOG_SUB_CALLWAIT].owner) { + /* There's a call waiting call, so ring the phone, but make it unowned in the mean time */ + analog_swap_subs(p, ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL); + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Channel %d still has (callwait) call, ringing phone\n", p->channel); + analog_unalloc_sub(p, ANALOG_SUB_CALLWAIT); + analog_stop_callwait(p); + p->owner = NULL; + /* Don't start streaming audio yet if the incoming call isn't up yet */ + if (p->subs[ANALOG_SUB_REAL].owner->_state != AST_STATE_UP) + p->dialing = 1; + analog_ring(p); + } else if (p->subs[ANALOG_SUB_THREEWAY].owner) { + unsigned int mssinceflash; + /* Here we have to retain the lock on both the main channel, the 3-way channel, and + the private structure -- not especially easy or clean */ + while (p->subs[ANALOG_SUB_THREEWAY].owner && ast_channel_trylock(p->subs[ANALOG_SUB_THREEWAY].owner)) { + /* Yuck, didn't get the lock on the 3-way, gotta release everything and re-grab! */ + analog_unlock_private(p); + CHANNEL_DEADLOCK_AVOIDANCE(ast); + /* We can grab ast and p in that order, without worry. We should make sure + nothing seriously bad has happened though like some sort of bizarre double + masquerade! */ + analog_lock_private(p); + if (p->owner != ast) { + ast_log(LOG_WARNING, "This isn't good...\n"); + return NULL; + } + } + if (!p->subs[ANALOG_SUB_THREEWAY].owner) { + ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n"); + return NULL; + } + mssinceflash = ast_tvdiff_ms(ast_tvnow(), p->flashtime); + ast_debug(1, "Last flash was %d ms ago\n", mssinceflash); + if (mssinceflash < MIN_MS_SINCE_FLASH) { + /* It hasn't been long enough since the last flashook. This is probably a bounce on + hanging up. Hangup both channels now */ + if (p->subs[ANALOG_SUB_THREEWAY].owner) + ast_queue_hangup(p->subs[ANALOG_SUB_THREEWAY].owner); + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel); + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + } else if ((ast->pbx) || (ast->_state == AST_STATE_UP)) { + if (p->transfer) { + /* In any case this isn't a threeway call anymore */ + p->subs[ANALOG_SUB_REAL].inthreeway = 0; + p->subs[ANALOG_SUB_THREEWAY].inthreeway = 0; + /* Only attempt transfer if the phone is ringing; why transfer to busy tone eh? */ + if (!p->transfertobusy && ast->_state == AST_STATE_BUSY) { + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + /* Swap subs and dis-own channel */ + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + p->owner = NULL; + /* Ring the phone */ + analog_ring(p); + } else { + if ((res = analog_attempt_transfer(p)) < 0) { + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + if (p->subs[ANALOG_SUB_THREEWAY].owner) + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + } else if (res) { + /* Don't actually hang up at this point */ + if (p->subs[ANALOG_SUB_THREEWAY].owner) + ast_channel_unlock(&p->subs[ANALOG_SUB_THREEWAY].owner); + break; + } + } + } else { + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + if (p->subs[ANALOG_SUB_THREEWAY].owner) + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + } + } else { + ast_channel_unlock(p->subs[ANALOG_SUB_THREEWAY].owner); + /* Swap subs and dis-own channel */ + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + p->owner = NULL; + /* Ring the phone */ + analog_ring(p); + } + } + } else { + ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", index); + } + /* Fall through */ + default: + analog_set_echocanceller(p, 0); + return NULL; + } + break; + case ANALOG_EVENT_RINGOFFHOOK: + if (p->inalarm) break; + /* for E911, its supposed to wait for offhook then dial + the second half of the dial string */ + if (((mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA) || (mysig == ANALOG_SIG_FGC_CAMAMF)) && (ast->_state == AST_STATE_DIALING_OFFHOOK)) { + c = strchr(p->dialdest, '/'); + if (c) + c++; + else + c = p->dialdest; + if (*c) snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*0%s#", c); + else ast_copy_string(p->dop.dialstr,"M*2#", sizeof(p->dop.dialstr)); + if (strlen(p->dop.dialstr) > 4) { + memset(p->echorest, 'w', sizeof(p->echorest) - 1); + strcpy(p->echorest + (p->echotraining / 401) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2); + p->echorest[sizeof(p->echorest) - 1] = '\0'; + p->echobreak = 1; + p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0'; + } else + p->echobreak = 0; + if (analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop)) { + int saveerr = errno; + analog_on_hook(p); + ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr)); + return NULL; + } + p->dialing = 1; + return &p->subs[index].f; + } + switch (p->sig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + switch (ast->_state) { + case AST_STATE_RINGING: + analog_set_echocanceller(p, 1); + analog_train_echocanceller(p); + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_ANSWER; + /* Make sure it stops ringing */ + analog_off_hook(p); + ast_debug(1, "channel %d answered\n", p->channel); + p->dialing = 0; + p->callwaitcas = 0; + if (!ast_strlen_zero(p->dop.dialstr)) { + /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */ + res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; + } else { + ast_debug(1, "Sent FXO deferred digit string: %s\n", p->dop.dialstr); + p->subs[index].f.frametype = AST_FRAME_NULL; + p->subs[index].f.subclass = 0; + p->dialing = 1; + } + p->dop.dialstr[0] = '\0'; + ast_setstate(ast, AST_STATE_DIALING); + } else + ast_setstate(ast, AST_STATE_UP); + return &p->subs[index].f; + case AST_STATE_DOWN: + ast_setstate(ast, AST_STATE_RING); + ast->rings = 1; + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_OFFHOOK; + ast_debug(1, "channel %d picked up\n", p->channel); + return &p->subs[index].f; + case AST_STATE_UP: + /* Make sure it stops ringing */ + analog_off_hook(p); + /* Okay -- probably call waiting*/ + if (ast_bridged_channel(p->owner)) + ast_queue_control(p->owner, AST_CONTROL_UNHOLD); + break; + case AST_STATE_RESERVED: + /* Start up dialtone */ + if (analog_has_voicemail(p)) + res = analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_STUTTER); + else + res = analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_DIALTONE); + break; + default: + ast_log(LOG_WARNING, "FXO phone off hook in weird state %d??\n", ast->_state); + } + break; + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: +#if 0 + if (ast->_state == AST_STATE_RING) { + p->ringt = p->ringt_base; + } +#endif + + /* Fall through */ + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SF: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + if (ast->_state == AST_STATE_PRERING) + ast_setstate(ast, AST_STATE_RING); + if ((ast->_state == AST_STATE_DOWN) || (ast->_state == AST_STATE_RING)) { + ast_debug(1, "Ring detected\n"); + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_RING; + } else if (p->outgoing && ((ast->_state == AST_STATE_RINGING) || (ast->_state == AST_STATE_DIALING))) { + ast_debug(1, "Line answered\n"); + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_ANSWER; + ast_setstate(ast, AST_STATE_UP); + } else if (ast->_state != AST_STATE_RING) + ast_log(LOG_WARNING, "Ring/Off-hook in strange state %d on channel %d\n", ast->_state, p->channel); + break; + default: + ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig); + } + break; +#ifdef ANALOG_EVENT_RINGBEGIN + case ANALOG_EVENT_RINGBEGIN: + switch (p->sig) { + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: +#if 0 + if (ast->_state == AST_STATE_RING) { + p->ringt = p->ringt_base; + } +#endif + break; + } + break; +#endif + case ANALOG_EVENT_RINGEROFF: + if (p->inalarm) break; + ast->rings++; + if (ast->rings == p->cidrings) { + analog_send_callerid(p, 0, &p->cid); + } + + if (ast->rings > p->cidrings) { + p->callwaitcas = 0; + } + p->subs[index].f.frametype = AST_FRAME_CONTROL; + p->subs[index].f.subclass = AST_CONTROL_RINGING; + break; + case ANALOG_EVENT_RINGERON: + break; + case ANALOG_EVENT_NOALARM: + p->inalarm = 0; + if (!p->unknown_alarm) { + ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel); + manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", + "Channel: %d\r\n", p->channel); + } else { + p->unknown_alarm = 0; + } + break; + case ANALOG_EVENT_WINKFLASH: + if (p->inalarm) break; + /* Remember last time we got a flash-hook */ + gettimeofday(&p->flashtime, NULL); + switch (mysig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: +#if 0 + ast_debug(1, "Winkflash, index: %d, normal: %d, callwait: %d, thirdcall: %d\n", + index, p->subs[ANALOG_SUB_REAL].dfd, p->subs[ANALOG_SUB_CALLWAIT].dfd, p->subs[ANALOG_SUB_THREEWAY].dfd); +#endif + p->callwaitcas = 0; + + if (index != ANALOG_SUB_REAL) { + ast_log(LOG_WARNING, "Got flash hook with index %d on channel %d?!?\n", index, p->channel); + goto winkflashdone; + } + + if (p->subs[ANALOG_SUB_CALLWAIT].owner) { + /* Swap to call-wait */ + int previous_state = p->subs[ANALOG_SUB_CALLWAIT].owner->_state; + if (p->subs[ANALOG_SUB_CALLWAIT].owner->_state == AST_STATE_RINGING) { + ast_setstate(p->subs[ANALOG_SUB_CALLWAIT].owner, AST_STATE_UP); + } + analog_swap_subs(p, ANALOG_SUB_REAL, ANALOG_SUB_CALLWAIT); + analog_play_tone(p, ANALOG_SUB_REAL, -1); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + ast_debug(1, "Making %s the new owner\n", p->owner->name); + if (previous_state == AST_STATE_RINGING) { + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_ANSWER); + } + analog_stop_callwait(p); + /* Start music on hold if appropriate */ + if (!p->subs[ANALOG_SUB_CALLWAIT].inthreeway && ast_bridged_channel(p->subs[ANALOG_SUB_CALLWAIT].owner)) { + ast_queue_control_data(p->subs[ANALOG_SUB_CALLWAIT].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_ANSWER); + if (ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)) { + ast_queue_control_data(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_UNHOLD); + } else if (!p->subs[ANALOG_SUB_THREEWAY].owner) { + char cid_num[256]; + char cid_name[256]; + + if (!p->threewaycalling) { + /* Just send a flash if no 3-way calling */ + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_FLASH); + goto winkflashdone; + } else if (!analog_check_for_conference(p)) { + if (p->dahditrcallerid && p->owner) { + if (p->owner->cid.cid_num) + ast_copy_string(cid_num, p->owner->cid.cid_num, sizeof(cid_num)); + if (p->owner->cid.cid_name) + ast_copy_string(cid_name, p->owner->cid.cid_name, sizeof(cid_name)); + } + /* XXX This section needs much more error checking!!! XXX */ + /* Start a 3-way call if feasible */ + if (!((ast->pbx) || + (ast->_state == AST_STATE_UP) || + (ast->_state == AST_STATE_RING))) { + ast_debug(1, "Flash when call not up or ringing\n"); + goto winkflashdone; + } + if (analog_alloc_sub(p, ANALOG_SUB_THREEWAY)) { + ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n"); + goto winkflashdone; + } + /* Make new channel */ + chan = analog_new_ast_channel(p, AST_STATE_RESERVED, 0, ANALOG_SUB_THREEWAY); + if (p->dahditrcallerid) { + if (!p->origcid_num) + p->origcid_num = ast_strdup(p->cid_num); + if (!p->origcid_name) + p->origcid_name = ast_strdup(p->cid_name); + ast_copy_string(p->cid_num, cid_num, sizeof(p->cid_num)); + ast_copy_string(p->cid_name, cid_name, sizeof(p->cid_name)); + } + /* Swap things around between the three-way and real call */ + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + /* Disable echo canceller for better dialing */ + analog_set_echocanceller(p, 0); + res = analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_DIALRECALL); + if (res) + ast_log(LOG_WARNING, "Unable to start dial recall tone on channel %d\n", p->channel); + p->ss_astchan = p->owner = chan; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + if (!chan) { + ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", p->channel); + } else if (ast_pthread_create(&threadid, &attr, __analog_ss_thread, p)) { + ast_log(LOG_WARNING, "Unable to start simple switch on channel %d\n", p->channel); + res = analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + analog_set_echocanceller(p, 1); + ast_hangup(chan); + } else { + struct ast_channel *other = ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner); + int way3bridge = 0, cdr3way = 0; + + if (!other) { + other = ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner); + } else + way3bridge = 1; + + if (p->subs[ANALOG_SUB_THREEWAY].owner->cdr) + cdr3way = 1; + + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Started three way call on channel %d\n", p->channel); + /* Start music on hold if appropriate */ + if (ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner)) { + ast_queue_control_data(p->subs[ANALOG_SUB_THREEWAY].owner, AST_CONTROL_HOLD, + S_OR(p->mohsuggest, NULL), + !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0); + } + } + pthread_attr_destroy(&attr); + } + } else { + /* Already have a 3 way call */ + if (p->subs[ANALOG_SUB_THREEWAY].inthreeway) { + /* Call is already up, drop the last person */ + ast_debug(1, "Got flash with three way call up, dropping last call on %d\n", p->channel); + /* If the primary call isn't answered yet, use it */ + if ((p->subs[ANALOG_SUB_REAL].owner->_state != AST_STATE_UP) && (p->subs[ANALOG_SUB_THREEWAY].owner->_state == AST_STATE_UP)) { + /* Swap back -- we're dropping the real 3-way that isn't finished yet*/ + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + } + /* Drop the last call and stop the conference */ + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Dropping three-way call on %s\n", p->subs[ANALOG_SUB_THREEWAY].owner->name); + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + p->subs[ANALOG_SUB_REAL].inthreeway = 0; + p->subs[ANALOG_SUB_THREEWAY].inthreeway = 0; + } else { + /* Lets see what we're up to */ + if (((ast->pbx) || (ast->_state == AST_STATE_UP)) && + (p->transfertobusy || (ast->_state != AST_STATE_BUSY))) { + int otherindex = ANALOG_SUB_THREEWAY; + struct ast_channel *other = ast_bridged_channel(p->subs[ANALOG_SUB_THREEWAY].owner); + int way3bridge = 0, cdr3way = 0; + + if (!other) { + other = ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner); + } else + way3bridge = 1; + + if (p->subs[ANALOG_SUB_THREEWAY].owner->cdr) + cdr3way = 1; + + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Building conference on call on %s and %s\n", p->subs[ANALOG_SUB_THREEWAY].owner->name, p->subs[ANALOG_SUB_REAL].owner->name); + /* Put them in the threeway, and flip */ + p->subs[ANALOG_SUB_THREEWAY].inthreeway = 1; + p->subs[ANALOG_SUB_REAL].inthreeway = 1; + if (ast->_state == AST_STATE_UP) { + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + otherindex = ANALOG_SUB_REAL; + } + if (p->subs[otherindex].owner && ast_bridged_channel(p->subs[otherindex].owner)) + ast_queue_control(p->subs[otherindex].owner, AST_CONTROL_UNHOLD); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + if (ast->_state == AST_STATE_RINGING) { + ast_debug(1, "Enabling ringtone on real and threeway\n"); + analog_play_tone(p, ANALOG_SUB_REAL, ANALOG_TONE_RINGTONE); + analog_play_tone(p, ANALOG_SUB_THREEWAY, ANALOG_TONE_RINGTONE); + } + } else { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Dumping incomplete call on on %s\n", p->subs[ANALOG_SUB_THREEWAY].owner->name); + analog_swap_subs(p, ANALOG_SUB_THREEWAY, ANALOG_SUB_REAL); + ast_softhangup_nolock(p->subs[ANALOG_SUB_THREEWAY].owner, AST_SOFTHANGUP_DEV); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + if (p->subs[ANALOG_SUB_REAL].owner && ast_bridged_channel(p->subs[ANALOG_SUB_REAL].owner)) + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_UNHOLD); + analog_set_echocanceller(p, 1); + } + } + } + winkflashdone: + analog_update_conf(p); + break; + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_SF: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + if (p->dialing) + ast_debug(1, "Ignoring wink on channel %d\n", p->channel); + else + ast_debug(1, "Got wink in weird state %d on channel %d\n", ast->_state, p->channel); + break; + case ANALOG_SIG_FEATDMF_TA: + switch (p->whichwink) { + case 0: + ast_debug(1, "ANI2 set to '%d' and ANI is '%s'\n", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); + snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%d%s#", p->owner->cid.cid_ani2, p->owner->cid.cid_ani); + break; + case 1: + ast_copy_string(p->dop.dialstr, p->finaldial, sizeof(p->dop.dialstr)); + break; + case 2: + ast_log(LOG_WARNING, "Received unexpected wink on channel of type ANALOG_SIG_FEATDMF_TA\n"); + return NULL; + } + p->whichwink++; + /* Fall through */ + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + /* FGD MF *Must* wait for wink */ + if (!ast_strlen_zero(p->dop.dialstr)) { + res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; + } else + ast_debug(1, "Sent deferred digit string on channel %d: %s\n", p->channel, p->dop.dialstr); + } + p->dop.dialstr[0] = '\0'; + break; + default: + ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig); + } + break; + case ANALOG_EVENT_HOOKCOMPLETE: + if (p->inalarm) break; + switch (mysig) { + case ANALOG_SIG_FXSLS: /* only interesting for FXS */ + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_SF: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF_FEATD: + if (!ast_strlen_zero(p->dop.dialstr)) { + res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno)); + p->dop.dialstr[0] = '\0'; + return NULL; + } else + ast_debug(1, "Sent deferred digit string on channel %d: %s\n", p->channel, p->dop.dialstr); + } + p->dop.dialstr[0] = '\0'; + p->dop.op = ANALOG_DIAL_OP_REPLACE; + break; + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + ast_debug(1, "Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->channel); + break; + default: + break; + } + break; + case ANALOG_EVENT_POLARITY: + /* + * If we get a Polarity Switch event, check to see + * if we should change the polarity state and + * mark the channel as UP or if this is an indication + * of remote end disconnect. + */ + if (p->polarity == POLARITY_IDLE) { + p->polarity = POLARITY_REV; + if (p->answeronpolarityswitch && + ((ast->_state == AST_STATE_DIALING) || + (ast->_state == AST_STATE_RINGING))) { + ast_debug(1, "Answering on polarity switch!\n"); + ast_setstate(p->owner, AST_STATE_UP); + if (p->hanguponpolarityswitch) { + gettimeofday(&p->polaritydelaytv, NULL); + } + } else + ast_debug(1, "Ignore switch to REVERSED Polarity on channel %d, state %d\n", p->channel, ast->_state); + } + /* Removed else statement from here as it was preventing hangups from ever happening*/ + /* Added AST_STATE_RING in if statement below to deal with calling party hangups that take place when ringing */ + if (p->hanguponpolarityswitch && + (p->polarityonanswerdelay > 0) && + (p->polarity == POLARITY_REV) && + ((ast->_state == AST_STATE_UP) || (ast->_state == AST_STATE_RING)) ) { + /* Added log_debug information below to provide a better indication of what is going on */ + ast_debug(1, "Polarity Reversal event occured - DEBUG 1: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); + + if (ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) > p->polarityonanswerdelay) { + ast_debug(1, "Polarity Reversal detected and now Hanging up on channel %d\n", p->channel); + ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); + p->polarity = POLARITY_IDLE; + } else { + ast_debug(1, "Polarity Reversal detected but NOT hanging up (too close to answer event) on channel %d, state %d\n", p->channel, ast->_state); + } + } else { + p->polarity = POLARITY_IDLE; + ast_debug(1, "Ignoring Polarity switch to IDLE on channel %d, state %d\n", p->channel, ast->_state); + } + /* Added more log_debug information below to provide a better indication of what is going on */ + ast_debug(1, "Polarity Reversal event occured - DEBUG 2: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) ); + break; + default: + ast_debug(1, "Dunno what to do with event %d on channel %d\n", res, p->channel); + } + return &p->subs[index].f; +} + +struct ast_frame *analog_exception(struct analog_pvt *p, struct ast_channel *ast) +{ + int res; + int usedindex=-1; + int index; + struct ast_frame *f; + + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + + index = analog_get_index(ast, p, 1); + + p->subs[index].f.frametype = AST_FRAME_NULL; + p->subs[index].f.datalen = 0; + p->subs[index].f.samples = 0; + p->subs[index].f.mallocd = 0; + p->subs[index].f.offset = 0; + p->subs[index].f.subclass = 0; + p->subs[index].f.delivery = ast_tv(0,0); + p->subs[index].f.src = "dahdi_exception"; + p->subs[index].f.data.ptr = NULL; + + + if (!p->owner) { + /* If nobody owns us, absorb the event appropriately, otherwise + we loop indefinitely. This occurs when, during call waiting, the + other end hangs up our channel so that it no longer exists, but we + have neither FLASH'd nor ONHOOK'd to signify our desire to + change to the other channel. */ + res = analog_get_event(p); + + /* Switch to real if there is one and this isn't something really silly... */ + if ((res != ANALOG_EVENT_RINGEROFF) && (res != ANALOG_EVENT_RINGERON) && + (res != ANALOG_EVENT_HOOKCOMPLETE)) { + ast_debug(1, "Restoring owner of channel %d on event %d\n", p->channel, res); + p->owner = p->subs[ANALOG_SUB_REAL].owner; + if (p->owner && ast_bridged_channel(p->owner)) + ast_queue_control(p->owner, AST_CONTROL_UNHOLD); + } + switch (res) { + case ANALOG_EVENT_ONHOOK: + analog_set_echocanceller(p, 0); + if (p->owner) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Channel %s still has call, ringing phone\n", p->owner->name); + analog_ring(p); + analog_stop_callwait(p); + } else + ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n"); + analog_update_conf(p); + break; + case ANALOG_EVENT_RINGOFFHOOK: + analog_set_echocanceller(p, 1); + analog_off_hook(p); + if (p->owner && (p->owner->_state == AST_STATE_RINGING)) { + ast_queue_control(p->subs[ANALOG_SUB_REAL].owner, AST_CONTROL_ANSWER); + p->dialing = 0; + } + break; + case ANALOG_EVENT_HOOKCOMPLETE: + case ANALOG_EVENT_RINGERON: + case ANALOG_EVENT_RINGEROFF: + /* Do nothing */ + break; + case ANALOG_EVENT_WINKFLASH: + gettimeofday(&p->flashtime, NULL); + if (p->owner) { + if (option_verbose > 2) + ast_verbose(VERBOSE_PREFIX_3 "Channel %d flashed to other channel %s\n", p->channel, p->owner->name); + if (p->owner->_state != AST_STATE_UP) { + /* Answer if necessary */ + usedindex = analog_get_index(p->owner, p, 0); + if (usedindex > -1) { + ast_queue_control(p->subs[usedindex].owner, AST_CONTROL_ANSWER); + } + ast_setstate(p->owner, AST_STATE_UP); + } + analog_stop_callwait(p); + if (ast_bridged_channel(p->owner)) + ast_queue_control(p->owner, AST_CONTROL_UNHOLD); + } else + ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n"); + analog_update_conf(p); + break; + default: + ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", analog_event2str(res)); + } + f = &p->subs[index].f; + return f; + } + ast_debug(1, "Exception on %d, channel %d\n", ast->fds[0],p->channel); + /* If it's not us, return NULL immediately */ + if (ast != p->owner) { + ast_log(LOG_WARNING, "We're %s, not %s\n", ast->name, p->owner->name); + f = &p->subs[index].f; + return f; + } + f = __analog_handle_event(p, ast); + return f; +} + +int analog_handle_init_event(struct analog_pvt *i, int event) +{ + int res; + pthread_t threadid; + pthread_attr_t attr; + struct ast_channel *chan; + + ast_debug(1, "channel (%d) - signaling (%d) - event (%s)\n", + i->channel, i->sig, analog_event2str(event)); + + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + /* Handle an event on a given channel for the monitor thread. */ + switch (event) { + case ANALOG_EVENT_WINKFLASH: + case ANALOG_EVENT_RINGOFFHOOK: + if (i->inalarm) break; + /* Got a ring/answer. What kind of channel are we? */ + switch (i->sig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FXOKS: + res = analog_off_hook(i); + if (res && (errno == EBUSY)) + break; + if (i->immediate) { + analog_set_echocanceller(i, 1); + /* The channel is immediately up. Start right away */ + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_RINGTONE); + chan = analog_new_ast_channel(i, AST_STATE_RING, 1, ANALOG_SUB_REAL); + if (!chan) { + ast_log(LOG_WARNING, "Unable to start PBX on channel %d\n", i->channel); + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel); + } + } else { + /* Check for callerid, digits, etc */ + chan = analog_new_ast_channel(i, AST_STATE_RESERVED, 0, ANALOG_SUB_REAL); + i->ss_astchan = chan; + if (chan) { + if (analog_has_voicemail(i)) + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_STUTTER); + else + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_DIALTONE); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play dialtone on channel %d, do you have defaultzone and loadzone defined?\n", i->channel); + if (ast_pthread_create(&threadid, &attr, __analog_ss_thread, i)) { + ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel); + ast_hangup(chan); + } + } else + ast_log(LOG_WARNING, "Unable to create channel\n"); + } + break; + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: +#if 0 + i->ringt = i->ringt_base; +#endif + /* Fall through */ + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + case ANALOG_SIG_SF: + /* Check for callerid, digits, etc */ + if (i->cid_start == ANALOG_CID_START_POLARITY_IN) { + chan = analog_new_ast_channel(i, AST_STATE_PRERING, 0, ANALOG_SUB_REAL); + } else { + chan = analog_new_ast_channel(i, AST_STATE_RING, 0, ANALOG_SUB_REAL); + } + i->ss_astchan = chan; + if (chan && ast_pthread_create(&threadid, &attr, __analog_ss_thread, i)) { + ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel); + ast_hangup(chan); + } else if (!chan) { + ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", i->channel); + } + break; + default: + ast_log(LOG_WARNING, "Don't know how to handle ring/answer with signalling %s on channel %d\n", analog_sigtype_to_str(i->sig), i->channel); + res = analog_play_tone(i, ANALOG_SUB_REAL, ANALOG_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel); + return -1; + } + break; + case ANALOG_EVENT_NOALARM: + i->inalarm = 0; + if (!i->unknown_alarm) { + ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", i->channel); + manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", + "Channel: %d\r\n", i->channel); + } else { + i->unknown_alarm = 0; + } + break; + case ANALOG_EVENT_ALARM: + i->inalarm = 1; +#if 0 + res = get_alarms(i); + handle_alarms(i, res); +#endif + /* fall thru intentionally */ + case ANALOG_EVENT_ONHOOK: + /* Back on hook. Hang up. */ + switch (i->sig) { + case ANALOG_SIG_FXOLS: + case ANALOG_SIG_FXOGS: + case ANALOG_SIG_FEATD: + case ANALOG_SIG_FEATDMF: + case ANALOG_SIG_FEATDMF_TA: + case ANALOG_SIG_E911: + case ANALOG_SIG_FGC_CAMA: + case ANALOG_SIG_FGC_CAMAMF: + case ANALOG_SIG_FEATB: + case ANALOG_SIG_EM: + case ANALOG_SIG_EM_E1: + case ANALOG_SIG_EMWINK: + case ANALOG_SIG_SF_FEATD: + case ANALOG_SIG_SF_FEATDMF: + case ANALOG_SIG_SF_FEATB: + case ANALOG_SIG_SF: + case ANALOG_SIG_SFWINK: + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSGS: + case ANALOG_SIG_FXSKS: + analog_set_echocanceller(i, 0); + res = analog_play_tone(i, ANALOG_SUB_REAL, -1); + analog_on_hook(i); + break; + case ANALOG_SIG_FXOKS: + analog_set_echocanceller(i, 0); + /* Diddle the battery for the zhone */ +#ifdef ZHONE_HACK + analog_off_hook(i); + usleep(1); +#endif + res = analog_play_tone(i, ANALOG_SUB_REAL, -1); + analog_on_hook(i); + break; + default: + ast_log(LOG_WARNING, "Don't know how to handle on hook with signalling %s on channel %d\n", analog_sigtype_to_str(i->sig), i->channel); + res = analog_play_tone(i, ANALOG_SUB_REAL, -1); + return -1; + } + break; + case ANALOG_EVENT_POLARITY: + switch (i->sig) { + case ANALOG_SIG_FXSLS: + case ANALOG_SIG_FXSKS: + case ANALOG_SIG_FXSGS: + /* We have already got a PR before the channel was + created, but it wasn't handled. We need polarity + to be REV for remote hangup detection to work. + At least in Spain */ + if (i->hanguponpolarityswitch) + i->polarity = POLARITY_REV; + + if (i->cid_start == ANALOG_CID_START_POLARITY || i->cid_start == ANALOG_CID_START_POLARITY_IN) { + i->polarity = POLARITY_REV; + ast_verbose(VERBOSE_PREFIX_2 "Starting post polarity " + "CID detection on channel %d\n", + i->channel); + chan = analog_new_ast_channel(i, AST_STATE_PRERING, 0, ANALOG_SUB_REAL); + i->ss_astchan = chan; + if (chan && ast_pthread_create(&threadid, &attr, __analog_ss_thread, i)) { + ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel); + } + } + break; + default: + ast_log(LOG_WARNING, "handle_init_event detected " + "polarity reversal on non-FXO (ANALOG_SIG_FXS) " + "interface %d\n", i->channel); + } + break; + case ANALOG_EVENT_NEONMWI_ACTIVE: + analog_handle_notify_message(NULL, i, -1, ANALOG_EVENT_NEONMWI_ACTIVE); + break; + case ANALOG_EVENT_NEONMWI_INACTIVE: + analog_handle_notify_message(NULL, i, -1, ANALOG_EVENT_NEONMWI_INACTIVE); + break; + } + pthread_attr_destroy(&attr); + return 0; +} + + +struct analog_pvt * analog_new(enum analog_sigtype signallingtype, struct analog_callback *c, void *private_data) +{ + struct analog_pvt *p; + + p = ast_calloc(1, sizeof(*p)); + + if (!p) + return p; + + p->calls = c; + p->outsigmod = ANALOG_SIG_NONE; + p->sig = signallingtype; + p->chan_pvt = private_data; + + /* Some defaults for values */ + p->sendcalleridafter = 1; + p->cid_start = ANALOG_CID_START_RING; + p->cid_signalling = CID_SIG_BELL; + /* Sub real is assumed to always be alloc'd */ + p->subs[ANALOG_SUB_REAL].allocd = 1; + + return p; +} + +int analog_config_complete(struct analog_pvt *p) +{ + /* No call waiting on non FXS channels */ + if ((p->sig != ANALOG_SIG_FXOKS) && (p->sig != ANALOG_SIG_FXOLS) && (p->sig != ANALOG_SIG_FXOGS)) + p->permcallwaiting = 0; + + p->callwaiting = p->permcallwaiting; + + return 0; +} + +void analog_free(struct analog_pvt *p) +{ + free(p); +} + +/* called while dahdi_pvt is locked in dahdi_fixup */ +int analog_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, void *newp) +{ + struct analog_pvt *new_pvt = newp; + int x; + ast_debug(1, "New owner for channel %d is %s\n", new_pvt->channel, newchan->name); + if (new_pvt->owner == oldchan) { + new_pvt->owner = newchan; + } + for (x = 0; x < 3; x++) + if (new_pvt->subs[x].owner == oldchan) { + new_pvt->subs[x].owner = newchan; + } + + analog_update_conf(new_pvt); + return 0; +} diff --git a/channels/sig_analog.h b/channels/sig_analog.h new file mode 100644 index 000000000..91e154353 --- /dev/null +++ b/channels/sig_analog.h @@ -0,0 +1,329 @@ +#ifndef _SIG_ANALOG_H +#define _SIG_ANALOG_H +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2009, Digium, Inc. + * + * Mark Spencer <markster@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Interface header for analog signaling module + * + * \author Matthew Fredrickson <creslin@digium.com> + */ + +#include "asterisk/channel.h" +#include "asterisk/frame.h" + +/* Signalling types supported */ +enum analog_sigtype { + ANALOG_SIG_NONE = -1, + ANALOG_SIG_FXOLS = 1, + ANALOG_SIG_FXOKS, + ANALOG_SIG_FXOGS, + ANALOG_SIG_FXSLS, + ANALOG_SIG_FXSKS, + ANALOG_SIG_FXSGS, + ANALOG_SIG_EMWINK, + ANALOG_SIG_EM, + ANALOG_SIG_EM_E1, + ANALOG_SIG_FEATD, + ANALOG_SIG_FEATDMF, + ANALOG_SIG_E911, + ANALOG_SIG_FGC_CAMA, + ANALOG_SIG_FGC_CAMAMF, + ANALOG_SIG_FEATB, + ANALOG_SIG_SFWINK, + ANALOG_SIG_SF, + ANALOG_SIG_SF_FEATD, + ANALOG_SIG_SF_FEATDMF, + ANALOG_SIG_FEATDMF_TA, + ANALOG_SIG_SF_FEATB, +}; + +enum analog_tone { + ANALOG_TONE_RINGTONE = 0, + ANALOG_TONE_STUTTER, + ANALOG_TONE_CONGESTION, + ANALOG_TONE_DIALTONE, + ANALOG_TONE_DIALRECALL, + ANALOG_TONE_INFO, +}; + +enum analog_event { + ANALOG_EVENT_NONE = 0, + ANALOG_EVENT_DIALCOMPLETE, + ANALOG_EVENT_WINKFLASH, + ANALOG_EVENT_ONHOOK, + ANALOG_EVENT_RINGOFFHOOK, + ANALOG_EVENT_ALARM, + ANALOG_EVENT_NOALARM, + ANALOG_EVENT_HOOKCOMPLETE, + ANALOG_EVENT_POLARITY, + ANALOG_EVENT_RINGERON, + ANALOG_EVENT_RINGEROFF, + ANALOG_EVENT_RINGBEGIN, + ANALOG_EVENT_PULSE_START, + ANALOG_EVENT_ERROR, + ANALOG_EVENT_NEONMWI_ACTIVE, + ANALOG_EVENT_NEONMWI_INACTIVE, +}; + +enum analog_sub { + ANALOG_SUB_REAL = 0, /*!< Active call */ + ANALOG_SUB_CALLWAIT, /*!< Call-Waiting call on hold */ + ANALOG_SUB_THREEWAY, /*!< Three-way call */ +}; + +enum analog_dsp_digitmode { + ANALOG_DIGITMODE_DTMF = 1, + ANALOG_DIGITMODE_MF, +}; + +enum analog_cid_start { + ANALOG_CID_START_POLARITY = 1, + ANALOG_CID_START_POLARITY_IN, + ANALOG_CID_START_RING, +}; + +#define ANALOG_MAX_CID 300 + +enum dialop { + ANALOG_DIAL_OP_REPLACE = 2, +}; + + +struct analog_dialoperation { + enum dialop op; + char dialstr[256]; +}; + +struct analog_callback { + /* Unlock the private in the signalling private structure. This is used for three way calling madness. */ + void (* const unlock_private)(void *pvt); + /* Lock the private in the signalling private structure. ... */ + void (* const lock_private)(void *pvt); + /* Function which is called back to handle any other DTMF up events that are received. Called by analog_handle_event. Why is this + * important to use, instead of just directly using events received before they are passed into the library? Because sometimes, + * (CWCID) the library absorbs DTMF events received. */ + void (* const handle_dtmfup)(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest); + + int (* const get_event)(void *pvt); + int (* const wait_event)(void *pvt); + int (* const is_off_hook)(void *pvt); + int (* const is_dialing)(void *pvt, enum analog_sub sub); + /* Start a trunk type signalling protocol (everything except phone ports basically */ + int (* const start)(void *pvt); + int (* const ring)(void *pvt); + int (* const flash)(void *pvt); + /*! \brief Set channel on hook */ + int (* const on_hook)(void *pvt); + /*! \brief Set channel off hook */ + int (* const off_hook)(void *pvt); + /* We're assuming that we're going to only wink on ANALOG_SUB_REAL - even though in the code there's an argument to the index + * function */ + int (* const wink)(void *pvt, enum analog_sub sub); + int (* const dial_digits)(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop); + int (* const send_fsk)(void *pvt, struct ast_channel *ast, char *fsk); + int (* const play_tone)(void *pvt, enum analog_sub sub, enum analog_tone tone); + + int (* const set_echocanceller)(void *pvt, int enable); + int (* const train_echocanceller)(void *pvt); + int (* const dsp_set_digitmode)(void *pvt, enum analog_dsp_digitmode mode); + int (* const dsp_reset_and_flush_digits)(void *pvt); + int (* const send_callerid)(void *pvt, int cwcid, struct ast_callerid *cid); + /* Returns 0 if CID received. Returns 1 if event received, and -1 if error. name and num are size ANALOG_MAX_CID */ + int (* const get_callerid)(void *pvt, char *name, char *num, enum analog_event *ev, size_t timeout); + /* Start CID detection */ + int (* const start_cid_detect)(void *pvt, int cid_signalling); + /* Stop CID detection */ + int (* const stop_cid_detect)(void *pvt); + + /* Play the CAS callwait tone on the REAL sub, then repeat after 10 seconds, and then stop */ + int (* const callwait)(void *pvt); + /* Stop playing any CAS call waiting announcement tones that might be running on the REAL sub */ + int (* const stop_callwait)(void *pvt); + + /* Bearer control related (non signalling) callbacks */ + int (* const allocate_sub)(void *pvt, enum analog_sub sub); + int (* const unallocate_sub)(void *pvt, enum analog_sub sub); + /*! This function is for swapping of the owners with the underlying subs. Typically it means you need to change the fds + * of the new owner to be the fds of the sub specified, for each of the two subs given */ + void (* const swap_subs)(void *pvt, enum analog_sub a, struct ast_channel *new_a_owner, enum analog_sub b, struct ast_channel *new_b_owner); + struct ast_channel * (* const new_ast_channel)(void *pvt, int state, int startpbx, enum analog_sub sub); + + /* Add the given sub to a conference */ + int (* const conf_add)(void *pvt, enum analog_sub sub); + /* Delete the given sub from any conference that might be running on the channels */ + int (* const conf_del)(void *pvt, enum analog_sub sub); + + /* If you would like to do any optimizations after the conference members have been added and removed, + * you can do so here */ + int (* const complete_conference_update)(void *pvt, int needconf); + + /* This is called when there are no more subchannels on the given private that are left up, + * for any cleanup or whatever else you would like to do. Called from analog_hangup() */ + void (* const all_subchannels_hungup)(void *pvt); + + int (* const has_voicemail)(void *pvt); + int (* const check_for_conference)(void *pvt); + void (* const handle_notify_message)(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent); + + /* callbacks for increasing and decreasing ss_thread_count, will handle locking and condition signal */ + void (* const increase_ss_count)(void); + void (* const decrease_ss_count)(void); +}; + + + +#define READ_SIZE 160 + +struct analog_subchannel { + struct ast_channel *owner; + struct ast_frame f; /*!< One frame for each channel. How did this ever work before? */ + unsigned int needcallerid:1; + unsigned int inthreeway:1; + /* Have we allocated a subchannel yet or not */ + unsigned int allocd:1; +}; + +struct analog_pvt { + /* Analog signalling type used in this private */ + enum analog_sigtype sig; + /* To contain the private structure passed into the channel callbacks */ + void *chan_pvt; + /* Callbacks for various functions needed by the analog API */ + struct analog_callback *calls; + /* All members after this are giong to be transient, and most will probably change */ + struct ast_channel *owner; /*!< Our current active owner (if applicable) */ + + struct analog_subchannel subs[3]; /*!< Sub-channels */ + struct analog_dialoperation dop; + + /* XXX: Option Variables - Set by allocator of private structure */ + unsigned int answeronpolarityswitch:1; + unsigned int callreturn:1; + unsigned int cancallforward:1; + unsigned int canpark:1; + unsigned int dahditrcallerid:1; /*!< should we use the callerid from incoming call on dahdi transfer or not */ + unsigned int hanguponpolarityswitch:1; + unsigned int immediate:1; + unsigned int permcallwaiting:1; + unsigned int permhidecallerid:1; /*!< Whether to hide our outgoing caller ID or not */ + unsigned int pulse:1; + unsigned int threewaycalling:1; + unsigned int transfer:1; + unsigned int transfertobusy:1; /*!< allow flash-transfers to busy channels */ + unsigned int use_callerid:1; /*!< Whether or not to use caller id on this channel */ + + /* Not used for anything but log messages. Could be just the TCID */ + int channel; /*!< Channel Number or CRV */ + enum analog_sigtype outsigmod; + int echotraining; + int cid_signalling; /*!< Asterisk callerid type we're using */ + int polarityonanswerdelay; + int stripmsd; + enum analog_cid_start cid_start; + /* Number of rings to wait to send callerid on FXS. Set to 1 for US */ + int sendcalleridafter; + int callwaitingcallerid; + char mohsuggest[MAX_MUSICCLASS]; + char cid_num[AST_MAX_EXTENSION]; + char cid_name[AST_MAX_EXTENSION]; + + + /* XXX: All variables after this are internal */ + unsigned int callwaiting:1; + unsigned int dialednone:1; + unsigned int dialing:1; + unsigned int dnd:1; + unsigned int echobreak:1; + unsigned int hidecallerid:1; + unsigned int outgoing:1; + unsigned int pulsedial:1; /*!< whether a pulse dial phone is detected */ + + char callwait_num[AST_MAX_EXTENSION]; + char callwait_name[AST_MAX_EXTENSION]; + char lastcid_num[AST_MAX_EXTENSION]; + char lastcid_name[AST_MAX_EXTENSION]; + struct ast_callerid cid; + int cidrings; /*!< Which ring to deliver CID on */ + char echorest[20]; + int polarity; + struct timeval polaritydelaytv; + char dialdest[256]; + time_t guardtime; /*!< Must wait this much time before using for new call */ + struct timeval flashtime; /*!< Last flash-hook time */ + int whichwink; /*!< SIG_FEATDMF_TA Which wink are we on? */ + char finaldial[64]; + char *origcid_num; /*!< malloced original callerid */ + char *origcid_name; /*!< malloced original callerid */ + char call_forward[AST_MAX_EXTENSION]; + + /* Ast channel to pass to __ss_analog_thread */ + void *ss_astchan; + + /* All variables after this are definitely going to be audited */ + unsigned int inalarm:1; // + unsigned int unknown_alarm:1;// + + int callwaitcas; + +#if 0 + int ringt; // + int ringt_base; +#endif +}; + +struct analog_pvt * analog_new(enum analog_sigtype signallingtype, struct analog_callback *c, void *private_data); + +void analog_free(struct analog_pvt *p); + +int analog_call(struct analog_pvt *p, struct ast_channel *ast, char *rdest, int timeout); + +int analog_hangup(struct analog_pvt *p, struct ast_channel *ast); + +int analog_answer(struct analog_pvt *p, struct ast_channel *ast); + +struct ast_frame *analog_exception(struct analog_pvt *p, struct ast_channel *ast); + +struct ast_channel * analog_request(struct analog_pvt *p, int *callwait); + +int analog_available(struct analog_pvt *p, int channelmatch, ast_group_t groupmatch, int *busy, int *channelmatched, int *groupmatched); + +int analog_handle_init_event(struct analog_pvt *i, int event); + +int analog_config_complete(struct analog_pvt *p); + +void analog_handle_dtmfup(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub index, struct ast_frame **dest); + +enum analog_cid_start analog_str_to_cidstart(const char *value); + +const char *analog_cidstart_to_str(enum analog_cid_start cid_start); + +enum analog_sigtype analog_str_to_sigtype(const char *name); + +const char *analog_sigtype_to_str(enum analog_sigtype sigtype); + +unsigned int analog_str_to_cidtype(const char *name); + +const char *analog_cidtype_to_str(unsigned int cid_type); + +int analog_ss_thread_start(struct analog_pvt *p, struct ast_channel *ast); + +int analog_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, void *newp); + +#endif /* _SIG_ANSLOG_H */ |