/* * Copyright (c) 2007-2014, Anthony Minessale II * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * * Neither the name of the original author; nor the names of any contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #ifdef WIN32 #include #else #include #endif #include "ftmod_isdn.h" #define LINE "--------------------------------------------------------------------------------" /* helper macros */ #define FTDM_SPAN_IS_NT(x) (((ftdm_isdn_data_t *)(x)->signal_data)->mode == Q921_NT) #define DEFAULT_NATIONAL_PREFIX "0" #define DEFAULT_INTERNATIONAL_PREFIX "00" /***************************************************************************************** * PCAP * Based on Helmut Kuper's () implementation, * but using a different approach (needs a recent libpcap + wireshark) *****************************************************************************************/ #ifdef HAVE_PCAP #include /* htons() */ #include #define PCAP_SNAPLEN 1500 struct pcap_context { pcap_dumper_t *dump; /*!< pcap file handle */ pcap_t *handle; /*!< pcap lib context */ char *filename; /*!< capture file name */ }; static inline ftdm_status_t isdn_pcap_is_open(struct ftdm_isdn_data *isdn) { return (isdn->pcap) ? 1 : 0; } static inline ftdm_status_t isdn_pcap_capture_both(struct ftdm_isdn_data *isdn) { return ((isdn->flags & (FTDM_ISDN_CAPTURE | FTDM_ISDN_CAPTURE_L3ONLY)) == FTDM_ISDN_CAPTURE) ? 1 : 0; } static inline ftdm_status_t isdn_pcap_capture_l3only(struct ftdm_isdn_data *isdn) { return ((isdn->flags & FTDM_ISDN_CAPTURE) && (isdn->flags & FTDM_ISDN_CAPTURE_L3ONLY)) ? 1 : 0; } static ftdm_status_t isdn_pcap_open(struct ftdm_isdn_data *isdn, char *filename) { struct pcap_context *pcap = NULL; if (!isdn || ftdm_strlen_zero(filename)) return FTDM_FAIL; pcap = malloc(sizeof(struct pcap_context)); if (!pcap) { ftdm_log(FTDM_LOG_ERROR, "Failed to allocate isdn pcap context\n"); return FTDM_FAIL; } memset(pcap, 0, sizeof(struct pcap_context)); pcap->filename = strdup(filename); pcap->handle = pcap_open_dead(DLT_LINUX_LAPD, PCAP_SNAPLEN); if (!pcap->handle) { ftdm_log(FTDM_LOG_ERROR, "Failed to open pcap handle\n"); goto error; } pcap->dump = pcap_dump_open(pcap->handle, pcap->filename); if (!pcap->dump) { ftdm_log(FTDM_LOG_ERROR, "Failed to open capture file: '%s'\n", pcap_geterr(pcap->handle)); goto error; } ftdm_log(FTDM_LOG_INFO, "Capture file '%s' opened\n", pcap->filename); isdn->pcap = pcap; return FTDM_SUCCESS; error: if (pcap->handle) pcap_close(pcap->handle); if (pcap->filename) free(pcap->filename); free(pcap); return FTDM_FAIL; } static ftdm_status_t isdn_pcap_close(struct ftdm_isdn_data *isdn) { struct pcap_context *pcap = NULL; long size; if (!isdn || !isdn->pcap) return FTDM_FAIL; pcap = isdn->pcap; isdn->flags &= ~(FTDM_ISDN_CAPTURE | FTDM_ISDN_CAPTURE_L3ONLY); isdn->pcap = NULL; pcap_dump_flush(pcap->dump); size = pcap_dump_ftell(pcap->dump); ftdm_log(FTDM_LOG_INFO, "File '%s' captured %ld bytes of data\n", pcap->filename, size); pcap_dump_close(pcap->dump); pcap_close(pcap->handle); free(pcap->filename); free(pcap); return FTDM_SUCCESS; } static inline void isdn_pcap_start(struct ftdm_isdn_data *isdn) { if (!isdn->pcap) return; isdn->flags |= FTDM_ISDN_CAPTURE; } static inline void isdn_pcap_stop(struct ftdm_isdn_data *isdn) { isdn->flags &= ~FTDM_ISDN_CAPTURE; } #ifndef ETH_P_LAPD #define ETH_P_LAPD 0x0030 #endif struct isdn_sll_hdr { uint16_t slltype; uint16_t sllhatype; uint16_t slladdrlen; uint8_t slladdr[8]; uint16_t sllproto; }; /* Fake Q.921 I-frame */ //static const char q921_fake_frame[] = { 0x00, 0x00, 0x00, 0x00 }; enum { ISDN_PCAP_INCOMING = 0, ISDN_PCAP_INCOMING_BCAST = 1, ISDN_PCAP_OUTGOING = 4, }; static ftdm_status_t isdn_pcap_write(struct ftdm_isdn_data *isdn, unsigned char *buf, ftdm_ssize_t len, int direction) { unsigned char frame[PCAP_SNAPLEN]; struct pcap_context *pcap; struct isdn_sll_hdr *sll_hdr = (struct isdn_sll_hdr *)frame; struct pcap_pkthdr hdr; int offset = sizeof(struct isdn_sll_hdr); int nbytes; if (!isdn || !isdn->pcap || !buf || !len) return FTDM_FAIL; pcap = isdn->pcap; /* Update SLL header */ sll_hdr->slltype = htons(direction); sll_hdr->sllhatype = 0; sll_hdr->slladdrlen = 1; sll_hdr->slladdr[0] = (isdn->mode == Q921_NT) ? 1 : 0; /* TODO: NT/TE */ sll_hdr->sllproto = htons(ETH_P_LAPD); #if 0 /* Q.931-only mode: copy fake Q.921 header */ if (isdn->flags & FTDM_ISDN_CAPTURE_L3ONLY) { /* copy fake q921 header */ memcpy(frame + offset, q921_fake_frame, sizeof(q921_fake_frame)); offset += sizeof(q921_fake_frame); } #endif /* Copy data */ nbytes = (len > (PCAP_SNAPLEN - offset)) ? (PCAP_SNAPLEN - offset) : len; memcpy(frame + offset, buf, nbytes); /* Update timestamp */ memset(&hdr, 0, sizeof(struct pcap_pkthdr)); gettimeofday(&hdr.ts, NULL); hdr.caplen = offset + nbytes; hdr.len = hdr.caplen; /* Write packet */ pcap_dump((unsigned char *)pcap->dump, &hdr, frame); return FTDM_SUCCESS; } #endif /* HAVE_PCAP */ static L2ULONG ftdm_time_now(void) { return (L2ULONG)ftdm_current_time_in_ms(); } /** * \brief Returns the signalling status on a channel * \param ftdmchan Channel to get status on * \param status Pointer to set signalling status * \return Success or failure */ static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(isdn_get_channel_sig_status) { *status = FTDM_SIG_STATE_DOWN; ftdm_isdn_data_t *isdn_data = ftdmchan->span->signal_data; if (ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { *status = FTDM_SIG_STATE_UP; } return FTDM_SUCCESS; } /** * \brief Returns the signalling status on a span * \param span Span to get status on * \param status Pointer to set signalling status * \return Success or failure */ static FIO_SPAN_GET_SIG_STATUS_FUNCTION(isdn_get_span_sig_status) { *status = FTDM_SIG_STATE_DOWN; ftdm_isdn_data_t *isdn_data = span->signal_data; if (ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { *status = FTDM_SIG_STATE_UP; } return FTDM_SUCCESS; } /** * \brief Create outgoing channel * \param ftdmchan Channel to create outgoing call on * \return Success or failure */ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call) { return FTDM_SUCCESS; } /** * \brief Create outgoing channel, let module select the channel to use * \param span Span to create outgoing call on * \param caller_data * \return Success or failure */ #ifdef __TODO__ static FIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) { #if 1 /* FIXME caller_data.raw_data does not exist anymore, see docs/variables.txt for more info */ Q931mes_Generic empty_gen; Q931mes_Generic *gen = &empty_gen; memset(&empty_gen, 0, sizeof(empty_gen)) ; #else Q931mes_Generic *gen = (Q931mes_Generic *) caller_data->raw_data; #endif Q931ie_BearerCap BearerCap; Q931ie_ChanID ChanID = { 0 }; Q931ie_CallingNum CallingNum; Q931ie_CallingNum *ptrCallingNum; Q931ie_CalledNum CalledNum; Q931ie_CalledNum *ptrCalledNum; Q931ie_Display Display, *ptrDisplay; Q931ie_HLComp HLComp; /* High-Layer Compatibility IE */ Q931ie_ProgInd Progress; /* Progress Indicator IE */ ftdm_status_t status = FTDM_FAIL; ftdm_isdn_data_t *isdn_data = span->signal_data; int sanity = 60000; int codec = 0; /* * get codec type */ ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_GET_NATIVE_CODEC, &codec); /* * Q.931 Setup Message */ Q931InitMesGeneric(gen); gen->MesType = Q931mes_SETUP; gen->CRVFlag = 0; /* outgoing call */ /* * Bearer Capability IE */ Q931InitIEBearerCap(&BearerCap); BearerCap.CodStand = Q931_CODING_ITU; /* ITU-T = 0, ISO/IEC = 1, National = 2, Network = 3 */ BearerCap.ITC = Q931_ITC_SPEECH; /* Speech */ BearerCap.TransMode = 0; /* Circuit = 0, Packet = 1 */ BearerCap.ITR = Q931_ITR_64K; /* 64k */ BearerCap.Layer1Ident = 1; BearerCap.UIL1Prot = (codec == FTDM_CODEC_ALAW) ? Q931_UIL1P_G711A : Q931_UIL1P_G711U; /* U-law = 2, A-law = 3 */ gen->BearerCap = Q931AppendIE(gen, (L3UCHAR *) &BearerCap); /* * Channel ID IE */ Q931InitIEChanID(&ChanID); ChanID.IntType = FTDM_SPAN_IS_BRI(span) ? 0 : 1; /* PRI = 1, BRI = 0 */ if (!FTDM_SPAN_IS_NT(span)) { ChanID.PrefExcl = (isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL) ? 0 : 1; /* 0 = preferred, 1 exclusive */ } else { ChanID.PrefExcl = 1; /* always exclusive in NT-mode */ } if (ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ ChanID.ChanSlot = (unsigned char)chan_id; } else { ChanID.InfoChanSel = (unsigned char)chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE(gen, (L3UCHAR *) &ChanID); /* * Progress IE */ Q931InitIEProgInd(&Progress); Progress.CodStand = Q931_CODING_ITU; /* 0 = ITU */ Progress.Location = 0; /* 0 = User, 1 = Private Network */ Progress.ProgDesc = 3; /* 1 = Not end-to-end ISDN */ gen->ProgInd = Q931AppendIE(gen, (L3UCHAR *)&Progress); /* * Display IE */ if (!(isdn_data->opts & FTDM_ISDN_OPT_OMIT_DISPLAY_IE) && FTDM_SPAN_IS_NT(span)) { Q931InitIEDisplay(&Display); Display.Size = Display.Size + (unsigned char)strlen(caller_data->cid_name); gen->Display = Q931AppendIE(gen, (L3UCHAR *) &Display); ptrDisplay = Q931GetIEPtr(gen->Display, gen->buf); ftdm_copy_string((char *)ptrDisplay->Display, caller_data->cid_name, strlen(caller_data->cid_name)+1); } /* * Calling Number IE */ Q931InitIECallingNum(&CallingNum); CallingNum.TypNum = Q931_TON_UNKNOWN; CallingNum.NumPlanID = Q931_NUMPLAN_E164; CallingNum.PresInd = Q931_PRES_ALLOWED; CallingNum.ScreenInd = Q931_SCREEN_USER_NOT_SCREENED; CallingNum.Size = CallingNum.Size + (unsigned char)strlen(caller_data->cid_num.digits); gen->CallingNum = Q931AppendIE(gen, (L3UCHAR *) &CallingNum); ptrCallingNum = Q931GetIEPtr(gen->CallingNum, gen->buf); ftdm_copy_string((char *)ptrCallingNum->Digit, caller_data->cid_num.digits, strlen(caller_data->cid_num.digits)+1); /* * Called number IE */ Q931InitIECalledNum(&CalledNum); CalledNum.TypNum = Q931_TON_UNKNOWN; CalledNum.NumPlanID = Q931_NUMPLAN_E164; CalledNum.Size = CalledNum.Size + (unsigned char)strlen(caller_data->ani.digits); gen->CalledNum = Q931AppendIE(gen, (L3UCHAR *) &CalledNum); ptrCalledNum = Q931GetIEPtr(gen->CalledNum, gen->buf); ftdm_copy_string((char *)ptrCalledNum->Digit, caller_data->ani.digits, strlen(caller_data->ani.digits)+1); /* * High-Layer Compatibility IE (Note: Required for AVM FritzBox) */ Q931InitIEHLComp(&HLComp); HLComp.CodStand = Q931_CODING_ITU; /* ITU */ HLComp.Interpret = 4; /* only possible value */ HLComp.PresMeth = 1; /* High-layer protocol profile */ HLComp.HLCharID = 1; /* Telephony = 1, Fax G2+3 = 4, Fax G4 = 65 (Class I)/ 68 (Class II or III) */ gen->HLComp = Q931AppendIE(gen, (L3UCHAR *) &HLComp); caller_data->call_state = FTDM_CALLER_STATE_DIALING; Q931Rx43(&isdn_data->q931, gen, gen->Size); isdn_data->outbound_crv[gen->CRV] = caller_data; //isdn_data->channels_local_crv[gen->CRV] = ftdmchan; while (ftdm_running() && caller_data->call_state == FTDM_CALLER_STATE_DIALING) { ftdm_sleep(1); if (!--sanity) { caller_data->call_state = FTDM_CALLER_STATE_FAIL; break; } } isdn_data->outbound_crv[gen->CRV] = NULL; if (caller_data->call_state == FTDM_CALLER_STATE_SUCCESS) { ftdm_channel_t *new_chan = NULL; int fail = 1; new_chan = NULL; if (caller_data->chan_id > 0 && caller_data->chan_id <= ftdm_span_get_chan_count(span)) { new_chan = ftdm_span_get_channel(span, caller_data->chan_id); } if (new_chan && (status = ftdm_channel_open_chan(new_chan) == FTDM_SUCCESS)) { if (ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE) || new_chan->state != FTDM_CHANNEL_STATE_DOWN) { if (new_chan->state == FTDM_CHANNEL_STATE_DOWN || new_chan->state >= FTDM_CHANNEL_STATE_TERMINATING) { int x = 0; ftdm_log(FTDM_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n"); for (x = 0; x < 200; x++) { if (!ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE)) { break; } ftdm_sleep(5); } } if (ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE)) { ftdm_log(FTDM_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", new_chan->span_id, new_chan->chan_id, new_chan->physical_span_id, new_chan->physical_chan_id ); new_chan = NULL; } } if (new_chan && new_chan->state == FTDM_CHANNEL_STATE_DOWN) { struct Q931_Call *call = NULL; memset(&new_chan->caller_data, 0, sizeof(new_chan->caller_data)); ftdm_set_flag(new_chan, FTDM_CHANNEL_OUTBOUND); ftdm_set_state_locked(new_chan, FTDM_CHANNEL_STATE_DIALING); call = Q931GetCallByCRV(&isdn_data->q931, gen->CRV); Q931CallSetPrivate(call, new_chan); switch(gen->MesType) { case Q931mes_ALERTING: new_chan->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA; break; case Q931mes_CONNECT: new_chan->init_state = FTDM_CHANNEL_STATE_UP; break; default: new_chan->init_state = FTDM_CHANNEL_STATE_PROGRESS; break; } fail = 0; } } if (!fail) { *ftdmchan = new_chan; return FTDM_SUCCESS; } else { Q931ie_Cause cause; gen->MesType = Q931mes_DISCONNECT; cause.IEId = Q931ie_CAUSE; cause.Size = sizeof(Q931ie_Cause); cause.CodStand = 0; cause.Location = 1; cause.Recom = 1; //should we be casting here.. or do we need to translate value? cause.Value = (unsigned char) FTDM_CAUSE_WRONG_CALL_STATE; *cause.Diag = '\0'; gen->Cause = Q931AppendIE(gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, gen, gen->Size); if (gen->CRV) { Q931ReleaseCRV(&isdn_data->q931, gen->CRV); } if (new_chan) { ftdm_log(FTDM_LOG_CRIT, "Channel is busy\n"); } else { ftdm_log(FTDM_LOG_CRIT, "Failed to open channel for new setup message\n"); } } } *ftdmchan = NULL; return FTDM_FAIL; } #endif /* __TODO__ */ static L3INT ftdm_isdn_931_err(void *pvt, L3INT id, L3INT p1, L3INT p2) { ftdm_log(FTDM_LOG_ERROR, "ERROR: [%s] [%d] [%d]\n", q931_error_to_name(id), p1, p2); return 0; } /** * \brief The new call event handler * \note W000t!!! \o/ ;D * \todo A lot */ static void ftdm_isdn_call_event(struct Q931_Call *call, struct Q931_CallEvent *event, void *priv) { Q931_TrunkInfo_t *trunk = NULL; ftdm_isdn_data_t *isdn_data = NULL; ftdm_span_t *span = priv; assert(span); assert(call); assert(event); trunk = Q931CallGetTrunk(call); assert(trunk); isdn_data = span->signal_data; assert(isdn_data); if (Q931CallIsGlobal(call)) { /* * Global event */ ftdm_log(FTDM_LOG_DEBUG, "Received global event from Q.931\n"); } else { ftdm_channel_t *ftdmchan = NULL; ftdm_sigmsg_t sig; int call_crv = Q931CallGetCRV(call); int type; /* * Call-specific event */ ftdm_log(FTDM_LOG_DEBUG, "Received call-specific event from Q.931 for call %d [%hu]\n", Q931CallGetCRV(call), Q931CallGetCRV(call)); /* * Try to get associated zap channel * and init sigmsg struct if there is one */ ftdmchan = Q931CallGetPrivate(call); if (ftdmchan) { memset(&sig, 0, sizeof(ftdm_sigmsg_t)); sig.chan_id = ftdmchan->chan_id; sig.span_id = ftdmchan->span_id; sig.channel = ftdmchan; } type = Q931CallEventGetType(event); if (type == Q931_EVENT_TYPE_CRV) { ftdm_log(FTDM_LOG_DEBUG, "\tCRV event\n"); switch (Q931CallEventGetId(event)) { case Q931_EVENT_RELEASE_CRV: { /* WARNING contains old interface code, yuck! */ if (!ftdmchan) { ftdm_log(FTDM_LOG_DEBUG, "Call %d [0x%x] not associated to zap channel\n", call_crv, call_crv); return; } if (ftdm_channel_get_state(ftdmchan) != FTDM_CHANNEL_STATE_DOWN && ftdm_channel_get_state(ftdmchan) != FTDM_CHANNEL_STATE_HANGUP_COMPLETE) { ftdm_log(FTDM_LOG_DEBUG, "Channel %d:%d not in DOWN state, cleaning up\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan)); /* * Send hangup signal to mod_openzap */ if (!sig.channel->caller_data.hangup_cause) { sig.channel->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING; } sig.event_id = FTDM_SIGEVENT_STOP; ftdm_span_send_signal(ftdm_channel_get_span(ftdmchan), &sig); /* Release zap channel */ ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } return; } break; default: ftdm_log(FTDM_LOG_ERROR, "Unknown CRV event: %d\n", Q931CallEventGetId(event)); return; } } else if (type == Q931_EVENT_TYPE_TIMER) { struct Q931_CallTimerEvent *timer_evt = Q931CallEventGetData(event); ftdm_log(FTDM_LOG_DEBUG, "\tTimer event\n"); assert(timer_evt->id); switch (timer_evt->id) { case Q931_TIMER_T303: /* * SETUP timeout * * TE-mode: Q931_EVENT_SETUP_CONFIRM (error) * NT-mode: Q931_EVENT_RELEASE_INDICATION */ { /* WARNING contains old interface code, yuck! */ if (!ftdmchan) { ftdm_log(FTDM_LOG_ERROR, "Call %d [0x%x] not associated to zap channel\n", call_crv, call_crv); return; } ftdm_log(FTDM_LOG_DEBUG, "Call setup failed on channel %d:%d\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan)); /* * Send signal to mod_openzap */ sig.channel->caller_data.hangup_cause = FTDM_CAUSE_NETWORK_OUT_OF_ORDER; sig.event_id = FTDM_SIGEVENT_STOP; ftdm_span_send_signal(ftdm_channel_get_span(ftdmchan), &sig); /* Release zap channel */ ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); return; } break; default: ftdm_log(FTDM_LOG_ERROR, "Unhandled timer event %d\n", timer_evt->id); } } else if (type == Q931_EVENT_TYPE_MESSAGE) { struct Q931_CallMessageEvent *msg_evt = Q931CallEventGetData(event); ftdm_log(FTDM_LOG_DEBUG, "\tMessage event\n"); assert(msg_evt); /* * Slowly move stuff from the old event handler into this part... */ switch (Q931CallEventGetId(event)) { case Q931_EVENT_SETUP_CONFIRM: case Q931_EVENT_SETUP_COMPLETE_INDICATION: /* CONNECT */ { /* WARNING contains old interface code, yuck! */ if (!ftdmchan) { ftdm_log(FTDM_LOG_ERROR, "Call %d [0x%x] not associated to zap channel\n", call_crv, call_crv); return; } ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); } break; default: ftdm_log(FTDM_LOG_DEBUG, "Not yet handled message event %d\n", Q931CallEventGetId(event)); } } else { ftdm_log(FTDM_LOG_ERROR, "Unknown event type %d\n", type); } } } /** * Copy callednum, readding prefix as needed */ static void __isdn_get_number(const char *digits, const int ton, char *buf, int size) { int offset = 0; if (!digits || !buf || size <= 0) return; switch (ton) { case Q931_TON_NATIONAL: offset = strlen(DEFAULT_NATIONAL_PREFIX); memcpy(buf, DEFAULT_NATIONAL_PREFIX, offset); break; case Q931_TON_INTERNATIONAL: offset = strlen(DEFAULT_INTERNATIONAL_PREFIX); memcpy(buf, DEFAULT_INTERNATIONAL_PREFIX, offset); break; default: break; } strncpy(&buf[offset], digits, size - (offset + 1)); buf[size - 1] = '\0'; } #define isdn_get_number(num, buf) \ __isdn_get_number((const char *)(num)->Digit, (num)->TypNum, (char *)buf, sizeof(buf)) /** * \brief The old call event handler (err, call message handler) * \todo This one must die! */ static L3INT ftdm_isdn_931_34(void *pvt, struct Q931_Call *call, Q931mes_Generic *msg, int mlen) { Q931mes_Generic *gen = (Q931mes_Generic *) msg; ftdm_span_t *span = (ftdm_span_t *) pvt; ftdm_isdn_data_t *isdn_data = span->signal_data; ftdm_channel_t *ftdmchan = NULL; int chan_id = 0; int chan_hunt = 0; if (Q931IsIEPresent(gen->ChanID)) { Q931ie_ChanID *chanid = Q931GetIEPtr(gen->ChanID, gen->buf); if (chanid->IntType) chan_id = chanid->ChanSlot; else chan_id = chanid->InfoChanSel; /* "any" channel specified */ if (chanid->InfoChanSel == 3) { chan_hunt++; } } else if (FTDM_SPAN_IS_NT(span)) { /* no channel ie */ chan_hunt++; } assert(span != NULL); assert(isdn_data != NULL); /* ftdm channel is stored in call private */ if (call) { ftdmchan = Q931CallGetPrivate(call); if (!ftdmchan) { ftdm_log(FTDM_LOG_DEBUG, "[s%d] No channel associated to call [%#x] private\n", ftdm_span_get_id(span), Q931CallGetCRV(call)); } } ftdm_log(FTDM_LOG_DEBUG, "Yay I got an event! Type:[%02x] Size:[%d] CRV: %d (%#hx, CTX: %s)\n", gen->MesType, gen->Size, gen->CRV, gen->CRV, gen->CRVFlag ? "Terminator" : "Originator"); #ifdef __TODO__ /* * This code block is needed for isdn_channel_request() * isdn_data->outbound_crv has been removed so another way to pass data around is required */ if (gen->CRVFlag && (caller_data = isdn_data->outbound_crv[gen->CRV])) { if (chan_id) { caller_data->chan_id = chan_id; } switch(gen->MesType) { case Q931mes_STATUS: case Q931mes_CALL_PROCEEDING: break; case Q931mes_ALERTING: case Q931mes_PROGRESS: case Q931mes_CONNECT: caller_data->call_state = FTDM_CALLER_STATE_SUCCESS; break; default: caller_data->call_state = FTDM_CALLER_STATE_FAIL; break; } return 0; } #endif ftdm_log(FTDM_LOG_DEBUG, "ftdmchan %p (%d:%d) via CRV[%#hx]\n", ftdmchan, ((ftdmchan) ? ftdm_channel_get_span_id(ftdmchan) : -1), ((ftdmchan) ? ftdm_channel_get_id(ftdmchan) : -1), gen->CRV); if (gen->ProtDisc == 3) { switch(gen->MesType) { case Q931mes_SERVICE: { Q931ie_ChangeStatus *changestatus = Q931GetIEPtr(gen->ChangeStatus, gen->buf); if (ftdmchan) { switch (changestatus->NewStatus) { case 0: /* change status to "in service" */ { ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); ftdm_log(FTDM_LOG_DEBUG, "Channel %d:%d in service\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan)); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } break; case 1: { /* change status to "maintenance" */ ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED); } break; case 2: { /* change status to "out of service" */ ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED); } break; default: /* unknown */ { break; } } } } break; default: break; } } else { switch(gen->MesType) { case Q931mes_RESTART: { if (chan_id) { ftdmchan = ftdm_span_get_channel(span, chan_id); } if (ftdmchan) { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } else { uint32_t i; for (i = 1; i < ftdm_span_get_chan_count(span); i++) { ftdmchan = ftdm_span_get_channel(span, chan_id); /* Skip channels that are down and D-Channels (#OpenZAP-39) */ if (ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DOWN || ftdm_channel_get_type(ftdmchan) == FTDM_CHAN_TYPE_DQ921) continue; ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } } break; case Q931mes_RELEASE: case Q931mes_RELEASE_COMPLETE: { const char *what = gen->MesType == Q931mes_RELEASE ? "Release" : "Release Complete"; if (ftdmchan) { if (ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_TERMINATING || ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_HANGUP) { if (gen->MesType == Q931mes_RELEASE) { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); } else { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } } else if (gen->MesType == Q931mes_RELEASE_COMPLETE && ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DIALTONE) { /* Go DOWN */ ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } else if ((gen->MesType == Q931mes_RELEASE && ftdm_channel_get_state(ftdmchan) <= FTDM_CHANNEL_STATE_UP) || (gen->MesType == Q931mes_RELEASE_COMPLETE && ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DIALING)) { /* * Don't keep inbound channels open if the remote side hangs up before we answered */ Q931ie_Cause *cause = Q931GetIEPtr(gen->Cause, gen->buf); ftdm_sigmsg_t sig; memset(&sig, 0, sizeof(sig)); sig.span_id = ftdm_channel_get_span_id(ftdmchan); sig.chan_id = ftdm_channel_get_id(ftdmchan); sig.channel = ftdmchan; sig.channel->caller_data.hangup_cause = (cause) ? cause->Value : FTDM_CAUSE_NORMAL_UNSPECIFIED; sig.event_id = FTDM_SIGEVENT_STOP; ftdm_span_send_signal(span, &sig); ftdm_log(FTDM_LOG_DEBUG, "Received %s in state %s, requested hangup for channel %d:%d\n", what, ftdm_channel_get_state_str(ftdmchan), ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan)); } else { ftdm_log(FTDM_LOG_DEBUG, "Ignoring %s on channel %d in state %s\n", what, ftdm_channel_get_id(ftdmchan), ftdm_channel_get_state_str(ftdmchan)); } } else { ftdm_log(FTDM_LOG_CRIT, "Received %s with no matching channel %d\n", what, chan_id); } } break; case Q931mes_DISCONNECT: { if (ftdmchan) { Q931ie_Cause *cause = Q931GetIEPtr(gen->Cause, gen->buf); ftdmchan->caller_data.hangup_cause = cause->Value; ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING); } else { ftdm_log(FTDM_LOG_CRIT, "Received Disconnect with no matching channel %d\n", chan_id); } } break; case Q931mes_ALERTING: { if (ftdmchan) { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } else { ftdm_log(FTDM_LOG_CRIT, "Received Alerting with no matching channel %d\n", chan_id); } } break; case Q931mes_PROGRESS: { if (ftdmchan) { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } else { ftdm_log(FTDM_LOG_CRIT, "Received Progress with no matching channel %d\n", chan_id); } } break; case Q931mes_CONNECT: #if 0 /* Handled by new event code */ { if (ftdmchan) { ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); #if 0 /* Auto-Ack is enabled, we actually don't need this */ gen->MesType = Q931mes_CONNECT_ACKNOWLEDGE; gen->CRVFlag = 0; /* outbound */ Q931Rx43(&isdn_data->q931, gen, gen->Size); #endif } else { ftdm_log(FTDM_LOG_CRIT, "Received Connect with no matching channel %d\n", chan_id); } } #endif break; case Q931mes_SETUP: { Q931ie_CallingNum *callingnum = Q931GetIEPtr(gen->CallingNum, gen->buf); Q931ie_CalledNum *callednum = Q931GetIEPtr(gen->CalledNum, gen->buf); int overlap_dial = 0; int fail_cause = 0; int fail = 1; if (ftdmchan && ftdmchan == Q931CallGetPrivate(call)) { ftdm_log(FTDM_LOG_INFO, "Duplicate SETUP message(?) for Channel %d:%d ~ %d:%d in state %s [ignoring]\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), ftdm_channel_get_ph_span_id(ftdmchan), ftdm_channel_get_ph_id(ftdmchan), ftdm_channel_get_state_str(ftdmchan)); break; } ftdmchan = NULL; /* * Channel selection for incoming calls: */ if (FTDM_SPAN_IS_NT(span) && chan_hunt) { int x; /* * In NT-mode with channel selection "any", * try to find a free channel */ for (x = 1; x <= ftdm_span_get_chan_count(span); x++) { ftdm_channel_t *zc = ftdm_span_get_channel(span, x); if (!ftdm_test_flag(zc, FTDM_CHANNEL_INUSE) && ftdm_channel_get_state(zc) == FTDM_CHANNEL_STATE_DOWN) { ftdmchan = zc; break; } } } else if (!FTDM_SPAN_IS_NT(span) && chan_hunt) { /* * In TE-mode this ("any") is invalid */ fail_cause = FTDM_CAUSE_CHANNEL_UNACCEPTABLE; ftdm_log(FTDM_LOG_ERROR, "Invalid channel selection in incoming call (network side didn't specify a channel)\n"); } else { /* * Otherwise simply try to select the channel we've been told * * TODO: NT mode is abled to select a different channel if the one chosen * by the TE side is already in use */ if (chan_id > 0 && chan_id < FTDM_MAX_CHANNELS_SPAN && chan_id <= ftdm_span_get_chan_count(span)) { ftdmchan = ftdm_span_get_channel(span, chan_id); } else { /* invalid channel id */ fail_cause = FTDM_CAUSE_CHANNEL_UNACCEPTABLE; ftdm_log(FTDM_LOG_ERROR, "Invalid channel selection in incoming call (none selected or out of bounds)\n"); } } if (!callednum || ftdm_strlen_zero((char *)callednum->Digit)) { if (FTDM_SPAN_IS_NT(span)) { ftdm_log(FTDM_LOG_NOTICE, "No destination number found, assuming overlap dial\n"); overlap_dial++; } else { ftdm_log(FTDM_LOG_ERROR, "No destination number found\n"); ftdmchan = NULL; } } if (ftdmchan) { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE) || ftdm_channel_get_state(ftdmchan) != FTDM_CHANNEL_STATE_DOWN) { if (ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DOWN || ftdm_channel_get_state(ftdmchan) >= FTDM_CHANNEL_STATE_TERMINATING) { int x = 0; ftdm_log(FTDM_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), ftdm_channel_get_ph_span_id(ftdmchan), ftdm_channel_get_ph_id(ftdmchan)); for (x = 0; x < 200; x++) { if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) { break; } ftdm_sleep(5); } } if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) { ftdm_log(FTDM_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), ftdm_channel_get_ph_span_id(ftdmchan), ftdm_channel_get_ph_id(ftdmchan)); ftdmchan = NULL; } } if (ftdmchan && ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DOWN) { ftdm_caller_data_t *caller_data = ftdm_channel_get_caller_data(ftdmchan); memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); if (ftdmchan->call_data) { memset(ftdmchan->call_data, 0, sizeof(ftdm_isdn_bchan_data_t)); } /* copy number readd prefix as needed */ isdn_get_number(callingnum, caller_data->cid_num.digits); isdn_get_number(callingnum, caller_data->cid_name); isdn_get_number(callingnum, caller_data->ani.digits); if (!overlap_dial) { isdn_get_number(callednum, caller_data->dnis.digits); } ftdmchan->caller_data.call_reference = gen->CRV; Q931CallSetPrivate(call, ftdmchan); gen->CRVFlag = !(gen->CRVFlag); fail = 0; } } if (fail) { Q931ie_Cause cause; gen->MesType = Q931mes_DISCONNECT; gen->CRVFlag = 1; /* inbound call */ cause.IEId = Q931ie_CAUSE; cause.Size = sizeof(Q931ie_Cause); cause.CodStand = Q931_CODING_ITU; cause.Location = 1; cause.Recom = 1; //should we be casting here.. or do we need to translate value? cause.Value = (unsigned char)((fail_cause) ? fail_cause : FTDM_CAUSE_WRONG_CALL_STATE); *cause.Diag = '\0'; gen->Cause = Q931AppendIE(gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, gen, gen->Size); if (gen->CRV) { Q931ReleaseCRV(&isdn_data->q931, gen->CRV); } if (ftdmchan) { ftdm_log_chan_msg(ftdmchan, FTDM_LOG_CRIT, "Channel is busy\n"); } else { ftdm_log(FTDM_LOG_CRIT, "Failed to open channel for new setup message\n"); } } else { Q931ie_ChanID ChanID; /* * Update Channel ID IE */ Q931InitIEChanID(&ChanID); ChanID.IntType = FTDM_SPAN_IS_BRI(ftdmchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ ChanID.PrefExcl = FTDM_SPAN_IS_NT(ftdmchan->span) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ if (ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ ChanID.ChanSlot = (unsigned char)ftdm_channel_get_id(ftdmchan); } else { ChanID.InfoChanSel = (unsigned char)ftdm_channel_get_id(ftdmchan) & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE(gen, (L3UCHAR *) &ChanID); if (overlap_dial) { Q931ie_ProgInd progress; /* * Setup Progress indicator */ progress.IEId = Q931ie_PROGRESS_INDICATOR; progress.Size = sizeof(Q931ie_ProgInd); progress.CodStand = Q931_CODING_ITU; /* ITU */ progress.Location = 1; /* private network serving the local user */ progress.ProgDesc = 8; /* call is not end-to-end isdn = 1, in-band information available = 8 */ gen->ProgInd = Q931AppendIE(gen, (L3UCHAR *) &progress); /* * Send SETUP ACK */ gen->MesType = Q931mes_SETUP_ACKNOWLEDGE; gen->CRVFlag = 1; /* inbound call */ Q931Rx43(&isdn_data->q931, gen, gen->Size); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALTONE); } else { /* * Advance to RING state */ ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); } } } break; case Q931mes_CALL_PROCEEDING: { if (ftdmchan) { ftdm_log_chan_msg(ftdmchan, FTDM_LOG_CRIT, "Received CALL PROCEEDING message for channel\n"); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } else { ftdm_log(FTDM_LOG_CRIT, "Received CALL PROCEEDING with no matching channel %d\n", chan_id); } } break; case Q931mes_CONNECT_ACKNOWLEDGE: { if (ftdmchan) { ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Received CONNECT_ACK message for channel\n"); } else { ftdm_log(FTDM_LOG_DEBUG, "Received CONNECT_ACK with no matching channel %d\n", chan_id); } } break; case Q931mes_INFORMATION: { if (ftdmchan) { ftdm_log_chan_msg(ftdmchan, FTDM_LOG_CRIT, "Received INFORMATION message for channel\n"); if (ftdm_channel_get_state(ftdmchan) == FTDM_CHANNEL_STATE_DIALTONE) { char digit = '\0'; /* * overlap dial digit indication */ if (Q931IsIEPresent(gen->CalledNum)) { ftdm_isdn_bchan_data_t *data = (ftdm_isdn_bchan_data_t *)ftdmchan->call_data; Q931ie_CalledNum *callednum = Q931GetIEPtr(gen->CalledNum, gen->buf); int pos; digit = callednum->Digit[strlen((char *)callednum->Digit) - 1]; if (digit == '#') { callednum->Digit[strlen((char *)callednum->Digit) - 1] = '\0'; } /* TODO: make this more safe with strncat() */ pos = strlen(ftdmchan->caller_data.dnis.digits); strcat(&ftdmchan->caller_data.dnis.digits[pos], (char *)callednum->Digit); /* update timer */ data->digit_timeout = ftdm_time_now() + isdn_data->digit_timeout; ftdm_log(FTDM_LOG_DEBUG, "Received new overlap digit (%s), destination number: %s\n", callednum->Digit, ftdmchan->caller_data.dnis.digits); } if (Q931IsIEPresent(gen->SendComplete) || digit == '#') { ftdm_log(FTDM_LOG_DEBUG, "Leaving overlap dial mode\n"); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); } } } else { ftdm_log(FTDM_LOG_CRIT, "Received INFORMATION message with no matching channel\n"); } } break; default: ftdm_log(FTDM_LOG_CRIT, "Received unhandled message %d (%#x)\n", (int)gen->MesType, (int)gen->MesType); break; } } return 0; } static int ftdm_isdn_921_23(void *pvt, Q921DLMsg_t ind, L2UCHAR tei, L2UCHAR *msg, L2INT mlen) { ftdm_span_t *span = pvt; ftdm_isdn_data_t *isdn_data = span->signal_data; int ret, offset = (ind == Q921_DL_DATA) ? 4 : 3; char bb[4096] = ""; switch(ind) { case Q921_DL_DATA: case Q921_DL_UNIT_DATA: print_hex_bytes(msg + offset, mlen - offset, bb, sizeof(bb)); ftdm_log(FTDM_LOG_DEBUG, "READ %d\n%s\n%s\n\n", (int)mlen - offset, LINE, bb); #ifdef HAVE_PCAP if (isdn_pcap_capture_l3only(isdn_data)) { isdn_pcap_write(isdn_data, msg, mlen, (ind == Q921_DL_UNIT_DATA) ? ISDN_PCAP_INCOMING_BCAST : ISDN_PCAP_INCOMING); } #endif default: ret = Q931Rx23(&isdn_data->q931, ind, tei, msg, mlen); if (ret != 0) ftdm_log(FTDM_LOG_DEBUG, "931 parse error [%d] [%s]\n", ret, q931_error_to_name(ret)); break; } return ((ret >= 0) ? 1 : 0); } static int ftdm_isdn_921_21(void *pvt, L2UCHAR *msg, L2INT mlen) { ftdm_span_t *span = (ftdm_span_t *) pvt; ftdm_size_t len = (ftdm_size_t) mlen; ftdm_isdn_data_t *isdn_data = span->signal_data; assert(span != NULL); #ifdef HAVE_PCAP if (isdn_pcap_capture_both(isdn_data)) { isdn_pcap_write(isdn_data, msg, mlen, ISDN_PCAP_OUTGOING); } #endif return ftdm_channel_write(isdn_data->dchan, msg, len, &len) == FTDM_SUCCESS ? 0 : -1; } static __inline__ void state_advance(ftdm_channel_t *ftdmchan) { ftdm_span_t *span = ftdm_channel_get_span(ftdmchan); ftdm_isdn_data_t *isdn_data = NULL; ftdm_sigmsg_t sig; ftdm_status_t status; Q931mes_Generic empty_gen; Q931mes_Generic *gen = &empty_gen; struct Q931_Call *call = NULL; Q931InitMesGeneric(gen); isdn_data = span->signal_data; assert(isdn_data); call = Q931GetCallByCRV(&isdn_data->q931, ftdmchan->caller_data.call_reference); if (call) { gen->CRV = Q931CallGetCRV(call); gen->CRVFlag = Q931CallGetDirection(call) == Q931_DIRECTION_INBOUND ? 1 : 0; } ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), ftdm_channel_get_state_str(ftdmchan)); memset(&sig, 0, sizeof(sig)); sig.span_id = ftdm_channel_get_span_id(ftdmchan); sig.chan_id = ftdm_channel_get_id(ftdmchan); sig.channel = ftdmchan; /* Acknowledge channel state change */ ftdm_channel_complete_state(ftdmchan); switch (ftdm_channel_get_state(ftdmchan)) { case FTDM_CHANNEL_STATE_DOWN: { if (gen->CRV) { Q931CallSetPrivate(call, NULL); Q931ReleaseCRV(&isdn_data->q931, gen->CRV); } ftdmchan->caller_data.call_reference = 0; ftdm_channel_close(&ftdmchan); } break; case FTDM_CHANNEL_STATE_PROGRESS: { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { sig.event_id = FTDM_SIGEVENT_PROGRESS; if ((status = ftdm_span_send_signal(ftdm_channel_get_span(ftdmchan), &sig) != FTDM_SUCCESS)) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { gen->MesType = Q931mes_CALL_PROCEEDING; if (FTDM_SPAN_IS_NT(ftdm_channel_get_span(ftdmchan))) { Q931ie_ChanID ChanID; /* * Set new Channel ID */ Q931InitIEChanID(&ChanID); ChanID.IntType = FTDM_SPAN_IS_BRI(ftdm_channel_get_span(ftdmchan)) ? 0 : 1; /* PRI = 1, BRI = 0 */ ChanID.PrefExcl = 1; /* always exclusive in NT-mode */ if (ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ ChanID.ChanSlot = (unsigned char)ftdm_channel_get_id(ftdmchan); } else { ChanID.InfoChanSel = (unsigned char)ftdm_channel_get_id(ftdmchan) & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE(gen, (L3UCHAR *) &ChanID); } Q931Rx43(&isdn_data->q931, gen, gen->Size); } } break; case FTDM_CHANNEL_STATE_DIALTONE: { ftdm_isdn_bchan_data_t *data = (ftdm_isdn_bchan_data_t *)ftdmchan->call_data; if (data) { data->digit_timeout = ftdm_time_now() + isdn_data->digit_timeout; } } break; case FTDM_CHANNEL_STATE_RING: { if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { sig.event_id = FTDM_SIGEVENT_START; if ((status = ftdm_span_send_signal(span, &sig) != FTDM_SUCCESS)) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } } break; case FTDM_CHANNEL_STATE_RESTART: { ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_UNSPECIFIED; sig.event_id = FTDM_SIGEVENT_RESTART; status = ftdm_span_send_signal(span, &sig); ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; if ((status = ftdm_span_send_signal(span, &sig) != FTDM_SUCCESS)) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); return; } } gen->MesType = Q931mes_ALERTING; Q931Rx43(&isdn_data->q931, gen, gen->Size); } } break; case FTDM_CHANNEL_STATE_UP: { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { sig.event_id = FTDM_SIGEVENT_UP; if ((status = ftdm_span_send_signal(span, &sig) != FTDM_SUCCESS)) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); return; } } gen->MesType = Q931mes_CONNECT; Q931Rx43(&isdn_data->q931, gen, gen->Size); } } break; case FTDM_CHANNEL_STATE_DIALING: if (!(isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL)) { ftdm_caller_data_t *caller_data = ftdm_channel_get_caller_data(ftdmchan); Q931ie_BearerCap BearerCap; Q931ie_ChanID ChanID; Q931ie_CallingNum CallingNum; Q931ie_CallingNum *ptrCallingNum; Q931ie_CalledNum CalledNum; Q931ie_CalledNum *ptrCalledNum; Q931ie_Display Display, *ptrDisplay; Q931ie_HLComp HLComp; /* High-Layer Compatibility IE */ Q931ie_ProgInd Progress; /* Progress Indicator IE */ int codec = 0; /* * get codec type */ ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_NATIVE_CODEC, &codec); /* * Q.931 Setup Message */ Q931InitMesGeneric(gen); gen->MesType = Q931mes_SETUP; gen->CRVFlag = 0; /* outbound(?) */ /* * Bearer Capability IE */ Q931InitIEBearerCap(&BearerCap); BearerCap.CodStand = Q931_CODING_ITU; /* ITU-T = 0, ISO/IEC = 1, National = 2, Network = 3 */ BearerCap.ITC = Q931_ITC_SPEECH; /* Speech */ BearerCap.TransMode = 0; /* Circuit = 0, Packet = 1 */ BearerCap.ITR = Q931_ITR_64K; /* 64k = 16, Packet mode = 0 */ BearerCap.Layer1Ident = 1; BearerCap.UIL1Prot = (codec == FTDM_CODEC_ALAW) ? 3 : 2; /* U-law = 2, A-law = 3 */ gen->BearerCap = Q931AppendIE(gen, (L3UCHAR *) &BearerCap); /* * ChannelID IE */ Q931InitIEChanID(&ChanID); ChanID.IntType = FTDM_SPAN_IS_BRI(ftdm_channel_get_span(ftdmchan)) ? 0 : 1; /* PRI = 1, BRI = 0 */ ChanID.PrefExcl = FTDM_SPAN_IS_NT(ftdm_channel_get_span(ftdmchan)) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ if (ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ ChanID.ChanSlot = (unsigned char)ftdm_channel_get_id(ftdmchan); } else { ChanID.InfoChanSel = (unsigned char)ftdm_channel_get_id(ftdmchan) & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE(gen, (L3UCHAR *) &ChanID); /* * Progress IE */ Q931InitIEProgInd(&Progress); Progress.CodStand = Q931_CODING_ITU; /* 0 = ITU */ Progress.Location = 0; /* 0 = User, 1 = Private Network */ Progress.ProgDesc = 3; /* 1 = Not end-to-end ISDN */ gen->ProgInd = Q931AppendIE(gen, (L3UCHAR *)&Progress); /* * Display IE */ if (!(isdn_data->opts & FTDM_ISDN_OPT_OMIT_DISPLAY_IE) && FTDM_SPAN_IS_NT(ftdm_channel_get_span(ftdmchan))) { Q931InitIEDisplay(&Display); Display.Size = Display.Size + (unsigned char)strlen(caller_data->cid_name); gen->Display = Q931AppendIE(gen, (L3UCHAR *) &Display); ptrDisplay = Q931GetIEPtr(gen->Display, gen->buf); ftdm_copy_string((char *)ptrDisplay->Display, caller_data->cid_name, strlen(caller_data->cid_name) + 1); } /* * CallingNum IE */ Q931InitIECallingNum(&CallingNum); CallingNum.TypNum = caller_data->ani.type; CallingNum.NumPlanID = Q931_NUMPLAN_E164; CallingNum.PresInd = Q931_PRES_ALLOWED; CallingNum.ScreenInd = Q931_SCREEN_USER_NOT_SCREENED; CallingNum.Size = CallingNum.Size + (unsigned char)strlen(caller_data->cid_num.digits); gen->CallingNum = Q931AppendIE(gen, (L3UCHAR *) &CallingNum); ptrCallingNum = Q931GetIEPtr(gen->CallingNum, gen->buf); ftdm_copy_string((char *)ptrCallingNum->Digit, caller_data->cid_num.digits, strlen(caller_data->cid_num.digits) + 1); /* * CalledNum IE */ Q931InitIECalledNum(&CalledNum); CalledNum.TypNum = Q931_TON_UNKNOWN; CalledNum.NumPlanID = Q931_NUMPLAN_E164; CalledNum.Size = CalledNum.Size + (unsigned char)strlen(caller_data->ani.digits); gen->CalledNum = Q931AppendIE(gen, (L3UCHAR *) &CalledNum); ptrCalledNum = Q931GetIEPtr(gen->CalledNum, gen->buf); ftdm_copy_string((char *)ptrCalledNum->Digit, caller_data->ani.digits, strlen(caller_data->ani.digits) + 1); /* * High-Layer Compatibility IE (Note: Required for AVM FritzBox) */ Q931InitIEHLComp(&HLComp); HLComp.CodStand = Q931_CODING_ITU; /* ITU */ HLComp.Interpret = 4; /* only possible value */ HLComp.PresMeth = 1; /* High-layer protocol profile */ HLComp.HLCharID = Q931_HLCHAR_TELEPHONY; /* Telephony = 1, Fax G2+3 = 4, Fax G4 = 65 (Class I)/ 68 (Class II or III) */ /* TODO: make accessible from user layer */ gen->HLComp = Q931AppendIE(gen, (L3UCHAR *) &HLComp); Q931Rx43(&isdn_data->q931, gen, gen->Size); /* * Support code for the new event handling system * Remove this as soon as we have the new api to set up calls */ if (gen->CRV) { call = Q931GetCallByCRV(&isdn_data->q931, gen->CRV); if (call) { ftdm_log(FTDM_LOG_DEBUG, "Storing reference to current span in call %d [0x%x]\n", gen->CRV, gen->CRV); Q931CallSetPrivate(call, ftdmchan); ftdmchan->caller_data.call_reference = gen->CRV; } } } break; case FTDM_CHANNEL_STATE_HANGUP_COMPLETE: { /* reply RELEASE with RELEASE_COMPLETE message */ if (ftdm_channel_get_last_state(ftdmchan) == FTDM_CHANNEL_STATE_HANGUP) { gen->MesType = Q931mes_RELEASE_COMPLETE; Q931Rx43(&isdn_data->q931, gen, gen->Size); } ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; case FTDM_CHANNEL_STATE_HANGUP: { ftdm_caller_data_t *caller_data = ftdm_channel_get_caller_data(ftdmchan); Q931ie_Cause cause; ftdm_log(FTDM_LOG_DEBUG, "Hangup: Call direction %s\n", ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); cause.IEId = Q931ie_CAUSE; cause.Size = sizeof(Q931ie_Cause); cause.CodStand = Q931_CODING_ITU; /* ITU */ cause.Location = 1; /* private network */ cause.Recom = 1; /* */ /* * BRI PTMP needs special handling here... * TODO: cleanup / refine (see above) */ if (ftdm_channel_get_last_state(ftdmchan) == FTDM_CHANNEL_STATE_RING) { /* * inbound call [was: number unknown (= not found in routing state)] * (in Q.931 spec terms: Reject request) */ if (!FTDM_SPAN_IS_NT(span)) { gen->MesType = Q931mes_RELEASE_COMPLETE; /* TE mode: Reject call */ ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } else { gen->MesType = Q931mes_DISCONNECT; /* NT mode: Disconnect and wait */ //ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); } //cause.Value = (unsigned char) FTDM_CAUSE_UNALLOCATED; cause.Value = (unsigned char) caller_data->hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE(gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, gen, gen->Size); /* we're done, release channel */ ////ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); //ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } else if (ftdm_channel_get_last_state(ftdmchan) <= FTDM_CHANNEL_STATE_PROGRESS) { /* * just release all unanswered calls [was: inbound call, remote side hung up before we answered] */ gen->MesType = Q931mes_RELEASE; cause.Value = (unsigned char) caller_data->hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE(gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, gen, gen->Size); /* this will be triggered by the RELEASE_COMPLETE reply */ /* ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); */ } else { /* * call connected, hangup */ gen->MesType = Q931mes_DISCONNECT; cause.Value = (unsigned char) caller_data->hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE(gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, gen, gen->Size); } } break; case FTDM_CHANNEL_STATE_TERMINATING: { ftdm_log(FTDM_LOG_DEBUG, "Terminating: Call direction %s\n", ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); sig.event_id = FTDM_SIGEVENT_STOP; status = ftdm_span_send_signal(span, &sig); gen->MesType = Q931mes_RELEASE; Q931Rx43(&isdn_data->q931, gen, gen->Size); } default: break; } } static __inline__ void check_state(ftdm_span_t *span) { if (ftdm_test_flag(span, FTDM_SPAN_STATE_CHANGE)) { uint32_t j; ftdm_clear_flag_locked(span, FTDM_SPAN_STATE_CHANGE); for (j = 1; j <= ftdm_span_get_chan_count(span); j++) { ftdm_channel_t *chan = ftdm_span_get_channel(span, j); if (ftdm_test_flag(chan, FTDM_CHANNEL_STATE_CHANGE)) { ftdm_channel_lock(chan); ftdm_clear_flag(chan, FTDM_CHANNEL_STATE_CHANGE); state_advance(chan); ftdm_channel_unlock(chan); } } } } static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event) { ftdm_alarm_flag_t alarmbits; ftdm_sigmsg_t sig; memset(&sig, 0, sizeof(sig)); sig.span_id = ftdm_channel_get_span_id(event->channel); sig.chan_id = ftdm_channel_get_id(event->channel); sig.channel = event->channel; ftdm_log(FTDM_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", ftdm_oob_event2str(event->enum_id), ftdm_channel_get_span_id(event->channel), ftdm_channel_get_id(event->channel), ftdm_channel_get_state_str(event->channel)); switch (event->enum_id) { case FTDM_OOB_ALARM_TRAP: { sig.event_id = FTDM_OOB_ALARM_TRAP; if (ftdm_channel_get_state(event->channel) != FTDM_CHANNEL_STATE_DOWN) { ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_RESTART); } ftdm_set_flag(event->channel, FTDM_CHANNEL_SUSPENDED); ftdm_channel_get_alarms(event->channel, &alarmbits); ftdm_span_send_signal(span, &sig); ftdm_log(FTDM_LOG_WARNING, "channel %d:%d (%d:%d) has alarms [%s]\n", ftdm_channel_get_span_id(event->channel), ftdm_channel_get_id(event->channel), ftdm_channel_get_ph_span_id(event->channel), ftdm_channel_get_ph_id(event->channel), ftdm_channel_get_last_error(event->channel)); } break; case FTDM_OOB_ALARM_CLEAR: { sig.event_id = FTDM_OOB_ALARM_CLEAR; ftdm_clear_flag(event->channel, FTDM_CHANNEL_SUSPENDED); ftdm_channel_get_alarms(event->channel, &alarmbits); ftdm_span_send_signal(span, &sig); } break; #ifdef __BROKEN_BY_FREETDM_CONVERSION__ case FTDM_OOB_DTMF: /* Taken from ozmod_analog, minus the CALLWAITING state handling */ { const char * digit_str = (const char *)event->data; if (digit_str) { fio_event_cb_t event_callback = NULL; ftdm_channel_queue_dtmf(event->channel, digit_str); if (span->event_callback) { event_callback = span->event_callback; } else if (event->channel->event_callback) { event_callback = event->channel->event_callback; } if (event_callback) { event->channel->event_header.channel = event->channel; event->channel->event_header.e_type = FTDM_EVENT_DTMF; event->channel->event_header.data = (void *)digit_str; event_callback(event->channel, &event->channel->event_header); event->channel->event_header.e_type = FTDM_EVENT_NONE; event->channel->event_header.data = NULL; } ftdm_safe_free(event->data); } } break; #endif } return FTDM_SUCCESS; } static __inline__ void check_events(ftdm_span_t *span) { ftdm_status_t status = ftdm_span_poll_event(span, 5, NULL); switch (status) { case FTDM_SUCCESS: { ftdm_event_t *event; while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { if (event->enum_id == FTDM_OOB_NOOP) { continue; } if (process_event(span, event) != FTDM_SUCCESS) { break; } } } break; case FTDM_FAIL: { ftdm_log(FTDM_LOG_DEBUG, "Event Failure! %d\n", ftdm_running()); } break; default: break; } } static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) { ftdm_buffer_t *dt_buffer = ts->user_data; int wrote; if (!dt_buffer) { return -1; } wrote = teletone_mux_tones(ts, map); ftdm_buffer_write(dt_buffer, ts->buffer, wrote * 2); return 0; } static void *ftdm_isdn_tones_run(ftdm_thread_t *me, void *obj) { ftdm_span_t *span = (ftdm_span_t *) obj; ftdm_isdn_data_t *isdn_data = span->signal_data; ftdm_buffer_t *dt_buffer = NULL; teletone_generation_session_t ts = {{{{0}}}};; unsigned char frame[1024]; int x, interval; ftdm_log(FTDM_LOG_DEBUG, "ISDN tones thread starting.\n"); ftdm_set_flag(isdn_data, FTDM_ISDN_TONES_RUNNING); if (ftdm_buffer_create(&dt_buffer, 1024, 1024, 0) != FTDM_SUCCESS) { snprintf(isdn_data->dchan->last_error, sizeof(isdn_data->dchan->last_error), "memory error!"); ftdm_log(FTDM_LOG_ERROR, "MEM ERROR\n"); goto done; } ftdm_buffer_set_loops(dt_buffer, -1); /* get a tone generation friendly interval to avoid distortions */ for (x = 1; x <= ftdm_span_get_chan_count(span); x++) { ftdm_channel_t *chan = ftdm_span_get_channel(span, x); if (ftdm_channel_get_type(chan) != FTDM_CHAN_TYPE_DQ921) { ftdm_channel_command(chan, FTDM_COMMAND_GET_INTERVAL, &interval); break; } } if (!interval) { interval = 20; } ftdm_log(FTDM_LOG_NOTICE, "Tone generating interval %d\n", interval); /* init teletone */ teletone_init_session(&ts, 0, teletone_handler, dt_buffer); ts.rate = 8000; ts.duration = ts.rate; /* main loop */ while (ftdm_running() && ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { ftdm_wait_flag_t flags; ftdm_status_t status; int last_chan_state = 0; int gated = 0; L2ULONG now = ftdm_time_now(); /* * check b-channel states and generate & send tones if neccessary */ for (x = 1; x <= ftdm_span_get_chan_count(span); x++) { ftdm_channel_t *chan = ftdm_span_get_channel(span, x); ftdm_size_t len = sizeof(frame), rlen; ftdm_isdn_bchan_data_t *data = chan->call_data; if (ftdm_channel_get_type(chan) == FTDM_CHAN_TYPE_DQ921) { continue; } /* * Generate tones based on current bchan state * (Recycle buffer content if succeeding channels share the * same state, this saves some cpu cycles) */ switch (ftdm_channel_get_state(chan)) { case FTDM_CHANNEL_STATE_DIALTONE: { ftdm_caller_data_t *caller_data = ftdm_channel_get_caller_data(chan); /* check overlap dial timeout first before generating tone */ if (data && data->digit_timeout && data->digit_timeout <= now) { if (strlen(caller_data->dnis.digits) > 0) { ftdm_log(FTDM_LOG_DEBUG, "Overlap dial timeout, advancing to RING state\n"); ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_RING); } else { /* no digits received, hangup */ ftdm_log(FTDM_LOG_DEBUG, "Overlap dial timeout, no digits received, going to HANGUP state\n"); caller_data->hangup_cause = FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE; /* TODO: probably wrong cause value */ ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_HANGUP); } data->digit_timeout = 0; continue; } if (last_chan_state != ftdm_channel_get_state(chan)) { ftdm_buffer_zero(dt_buffer); teletone_run(&ts, span->tone_map[FTDM_TONEMAP_DIAL]); last_chan_state = ftdm_channel_get_state(chan); } } break; case FTDM_CHANNEL_STATE_RING: { if (last_chan_state != ftdm_channel_get_state(chan)) { ftdm_buffer_zero(dt_buffer); teletone_run(&ts, span->tone_map[FTDM_TONEMAP_RING]); last_chan_state = ftdm_channel_get_state(chan); } } break; default: /* Not in a tone generating state, go to next round */ continue; } if (!ftdm_test_flag(chan, FTDM_CHANNEL_OPEN)) { if (ftdm_channel_open_chan(chan) != FTDM_SUCCESS) { ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_HANGUP); continue; } ftdm_log(FTDM_LOG_NOTICE, "Successfully opened channel %d:%d\n", ftdm_channel_get_span_id(chan), ftdm_channel_get_id(chan)); } flags = FTDM_READ; status = ftdm_channel_wait(chan, &flags, (gated) ? 0 : interval); switch (status) { case FTDM_FAIL: continue; case FTDM_TIMEOUT: gated = 1; continue; default: if (!(flags & FTDM_READ)) { continue; } } gated = 1; status = ftdm_channel_read(chan, frame, &len); if (status != FTDM_SUCCESS || len <= 0) { continue; } /* * Teletone operates on SLIN data (2 bytes per sample). * Convert the length of non-SLIN codecs, so we read * the right amount of samples from the buffer. */ if (chan->effective_codec != FTDM_CODEC_SLIN) { len *= 2; } /* seek to current offset */ ftdm_buffer_seek(dt_buffer, data->offset); /* * ftdm_channel_read() can read up to sizeof(frame) bytes * (in certain situations). Avoid overflowing the stack (and smashing dt_buffer) * if the codec is not slin and we had to double the length. */ len = ftdm_min(len, sizeof(frame)); rlen = ftdm_buffer_read_loop(dt_buffer, frame, len); if (chan->effective_codec != FTDM_CODEC_SLIN) { fio_codec_t codec_func = NULL; if (chan->native_codec == FTDM_CODEC_ULAW) { codec_func = fio_slin2ulaw; } else if (chan->native_codec == FTDM_CODEC_ALAW) { codec_func = fio_slin2alaw; } /* * Convert SLIN to native format (a-law/u-law), * input size is 2 bytes per sample, output size * (after conversion) is one byte per sample * (= max. half the input size). */ if (codec_func) { status = codec_func(frame, sizeof(frame), &rlen); } else { snprintf(chan->last_error, sizeof(chan->last_error), "codec error!"); goto done; } } if (ftdm_channel_write(chan, frame, sizeof(frame), &rlen) == FTDM_SUCCESS) { /* * Advance offset in teletone buffer by amount * of data actually written to channel. */ if (chan->effective_codec != FTDM_CODEC_SLIN) { data->offset += rlen << 1; /* Teletone buffer is in SLIN (= rlen * 2) */ } else { data->offset += rlen; } /* Limit offset to [0..Rate(Samples/s)-1] in SLIN (2 bytes per sample) units. */ data->offset %= (ts.rate << 1); } } /* * sleep a bit if there was nothing to do */ if (!gated) { ftdm_sleep(interval); } } done: if (ts.buffer) { teletone_destroy_session(&ts); } if (dt_buffer) { ftdm_buffer_destroy(&dt_buffer); } ftdm_log(FTDM_LOG_DEBUG, "ISDN tone thread ended.\n"); ftdm_clear_flag(isdn_data, FTDM_ISDN_TONES_RUNNING); return NULL; } static void *ftdm_isdn_run(ftdm_thread_t *me, void *obj) { ftdm_span_t *span = (ftdm_span_t *) obj; ftdm_isdn_data_t *isdn_data = span->signal_data; unsigned char frame[1024]; ftdm_size_t len = sizeof(frame); int errs = 0; #ifdef WIN32 timeBeginPeriod(1); #endif ftdm_log(FTDM_LOG_DEBUG, "ISDN thread starting.\n"); ftdm_set_flag(isdn_data, FTDM_ISDN_RUNNING); Q921Start(&isdn_data->q921); Q931Start(&isdn_data->q931); while (ftdm_running() && ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { ftdm_wait_flag_t flags = FTDM_READ; ftdm_status_t status = ftdm_channel_wait(isdn_data->dchan, &flags, 100); Q921TimerTick(&isdn_data->q921); Q931TimerTick(&isdn_data->q931); check_state(span); check_events(span); /* * */ switch (status) { case FTDM_FAIL: { ftdm_log(FTDM_LOG_ERROR, "D-Chan Read Error!\n"); snprintf(span->last_error, sizeof(span->last_error), "D-Chan Read Error!"); if (++errs == 10) { isdn_data->dchan->state = FTDM_CHANNEL_STATE_UP; goto done; } } break; case FTDM_TIMEOUT: { errs = 0; } break; default: { if (flags & FTDM_READ) { len = sizeof(frame); if (ftdm_channel_read(isdn_data->dchan, frame, &len) != FTDM_SUCCESS) { ftdm_log_chan_msg(isdn_data->dchan, FTDM_LOG_ERROR, "Failed to read from D-Channel\n"); continue; } if (len > 0) { #ifdef HAVE_PCAP if (isdn_pcap_capture_both(isdn_data)) { isdn_pcap_write(isdn_data, frame, len, ISDN_PCAP_INCOMING); } #endif Q921QueueHDLCFrame(&isdn_data->q921, frame, (int)len); Q921Rx12(&isdn_data->q921); /* Successful read, reset error counter */ errs = 0; } } else { ftdm_log(FTDM_LOG_DEBUG, "No Read FLAG!\n"); } } break; } } done: ftdm_channel_close(&isdn_data->dchan); ftdm_clear_flag(isdn_data, FTDM_ISDN_RUNNING); #ifdef WIN32 timeEndPeriod(1); #endif #ifdef HAVE_PCAP if (isdn_pcap_is_open(isdn_data)) { isdn_pcap_close(isdn_data); } #endif ftdm_log(FTDM_LOG_DEBUG, "ISDN thread ended.\n"); return NULL; } static int q931_rx_32(void *pvt, Q921DLMsg_t ind, L3UCHAR tei, L3UCHAR *msg, L3INT mlen) { ftdm_span_t *span = pvt; ftdm_isdn_data_t *isdn_data = span->signal_data; int offset = 4; char bb[4096] = ""; switch(ind) { case Q921_DL_UNIT_DATA: offset = 3; case Q921_DL_DATA: print_hex_bytes(msg + offset, mlen - offset, bb, sizeof(bb)); ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)mlen - offset, LINE, bb); break; default: break; } #ifdef HAVE_PCAP if (isdn_pcap_capture_l3only(isdn_data)) { isdn_pcap_write(isdn_data, msg, mlen, ISDN_PCAP_OUTGOING); } #endif return Q921Rx32(&isdn_data->q921, ind, tei, msg, mlen); } static int ftdm_isdn_q921_log(void *pvt, Q921LogLevel_t level, char *msg, L2INT size) { ftdm_span_t *span = (ftdm_span_t *) pvt; ftdm_log("Span", "Q.921", span->span_id, (int)level, "%s", msg); return 0; } static L3INT ftdm_isdn_q931_log(void *pvt, Q931LogLevel_t level, const char *msg, L3INT size) { ftdm_span_t *span = (ftdm_span_t *) pvt; ftdm_log("Span", "Q.931", span->span_id, (int)level, "%s", msg); return 0; } static ftdm_state_map_t isdn_state_map = { { { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_ANY_STATE}, {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, {FTDM_CHANNEL_STATE_DIALING, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_DIALING, FTDM_END}, {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_UP, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_UP, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, /****************************************/ { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_ANY_STATE}, {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, {FTDM_CHANNEL_STATE_DIALTONE, FTDM_CHANNEL_STATE_RING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_DIALTONE, FTDM_END}, {FTDM_CHANNEL_STATE_RING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_RING, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_CANCEL, FTDM_CHANNEL_STATE_UP, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, {FTDM_CHANNEL_STATE_UP, FTDM_END}, {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, }, } }; /** * \brief Stop signalling on span */ static ftdm_status_t ftdm_isdn_stop(ftdm_span_t *span) { ftdm_isdn_data_t *isdn_data = span->signal_data; if (!ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { return FTDM_FAIL; } ftdm_set_flag(isdn_data, FTDM_ISDN_STOP); while (ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { ftdm_sleep(100); } while (ftdm_test_flag(isdn_data, FTDM_ISDN_TONES_RUNNING)) { ftdm_sleep(100); } return FTDM_SUCCESS; } /** * \brief Start signalling on span */ static ftdm_status_t ftdm_isdn_start(ftdm_span_t *span) { ftdm_isdn_data_t *isdn_data = span->signal_data; ftdm_status_t ret; if (ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { return FTDM_FAIL; } ftdm_clear_flag(isdn_data, FTDM_ISDN_STOP); ret = ftdm_thread_create_detached(ftdm_isdn_run, span); if (ret != FTDM_SUCCESS) { return ret; } if (FTDM_SPAN_IS_NT(span) && !(isdn_data->opts & FTDM_ISDN_OPT_DISABLE_TONES)) { ret = ftdm_thread_create_detached(ftdm_isdn_tones_run, span); } return ret; } /*###################################################################* * (text) value parsing / translation *###################################################################*/ static int32_t parse_loglevel(const char *level) { if (!level) return -1; if (!strcasecmp(level, "debug")) { return FTDM_LOG_LEVEL_DEBUG; } else if (!strcasecmp(level, "info")) { return FTDM_LOG_LEVEL_INFO; } else if (!strcasecmp(level, "notice")) { return FTDM_LOG_LEVEL_NOTICE; } else if (!strcasecmp(level, "warning")) { return FTDM_LOG_LEVEL_WARNING; } else if (!strcasecmp(level, "error")) { return FTDM_LOG_LEVEL_ERROR; } else if (!strcasecmp(level, "alert")) { return FTDM_LOG_LEVEL_ALERT; } else if (!strcasecmp(level, "crit")) { return FTDM_LOG_LEVEL_CRIT; } else if (!strcasecmp(level, "emerg")) { return FTDM_LOG_LEVEL_EMERG; } else { return -1; } } static int parse_opts(const char *in, uint32_t *flags) { if (!in || !flags) return -1; if (strstr(in, "suggest_channel")) { *flags |= FTDM_ISDN_OPT_SUGGEST_CHANNEL; } if (strstr(in, "omit_display")) { *flags |= FTDM_ISDN_OPT_OMIT_DISPLAY_IE; } if (strstr(in, "disable_tones")) { *flags |= FTDM_ISDN_OPT_DISABLE_TONES; } return 0; } static int parse_dialect(const char *in, uint32_t *dialect) { if (!in || !dialect) return -1; #if __UNSUPPORTED__ if (!strcasecmp(in, "national")) { *dialect = Q931_Dialect_National; return 0; } if (!strcasecmp(in, "dms")) { *dialect = Q931_Dialect_DMS; return 0; } #endif if (!strcasecmp(in, "5ess")) { *dialect = Q931_Dialect_5ESS; return 0; } if (!strcasecmp(in, "dss1") || !strcasecmp(in, "euroisdn")) { *dialect = Q931_Dialect_DSS1; return 0; } if (!strcasecmp(in, "q931")) { *dialect = Q931_Dialect_Q931; return 0; } return -1; } /*###################################################################* * API commands *###################################################################*/ static const char isdn_api_usage[] = #ifdef HAVE_PCAP "isdn capture [q931only]\n" "isdn capture \n" #endif "isdn loglevel \n" "isdn dump calls\n" "isdn help"; /** * isdn_api */ static FIO_API_FUNCTION(isdn_api) { char *mycmd = NULL, *argv[10] = { 0 }; int argc = 0; if (data) { mycmd = strdup(data); argc = ftdm_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); } if (!argc || !strcasecmp(argv[0], "help")) { stream->write_function(stream, "%s\n", isdn_api_usage); goto done; } else if (!strcasecmp(argv[0], "dump")) { ftdm_isdn_data_t *isdn_data = NULL; ftdm_span_t *span = NULL; int span_id = 0; /* dump calls */ if (argc < 3) { stream->write_function(stream, "-ERR not enough arguments.\n"); goto done; } span_id = atoi(argv[1]); if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { isdn_data = span->signal_data; } else { stream->write_function(stream, "-ERR invalid span.\n"); goto done; } if (!strcasecmp(argv[2], "calls")) { /* dump all calls to log */ Q931DumpAllCalls(&isdn_data->q931); stream->write_function(stream, "+OK call information dumped to log\n"); goto done; } } else if (!strcasecmp(argv[0], "loglevel")) { ftdm_isdn_data_t *isdn_data = NULL; ftdm_span_t *span = NULL; int span_id = 0; int layer = 0; int level = 0; /* loglevel [level] */ if (argc < 3) { stream->write_function(stream, "-ERR not enough arguments.\n"); goto done; } span_id = atoi(argv[1]); if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { isdn_data = span->signal_data; } else { stream->write_function(stream, "-ERR invalid span.\n"); goto done; } if (!strcasecmp(argv[2], "q921")) { layer = 0x01; } else if (!strcasecmp(argv[2], "q931")) { layer = 0x02; } else if (!strcasecmp(argv[2], "all")) { layer = 0x03; } else { stream->write_function(stream, "-ERR invalid layer\n"); goto done; } if (argc > 3) { /* set loglevel */ if ((level = parse_loglevel(argv[3])) < 0) { stream->write_function(stream, "-ERR invalid loglevel\n"); goto done; } if (layer & 0x01) { /* q921 */ Q921SetLogLevel(&isdn_data->q921, (Q921LogLevel_t)level); } if (layer & 0x02) { /* q931 */ Q931SetLogLevel(&isdn_data->q931, (Q931LogLevel_t)level); } stream->write_function(stream, "+OK loglevel set"); } else { /* get loglevel */ if (layer & 0x01) { stream->write_function(stream, "Q.921 loglevel: %s\n", Q921GetLogLevelName(&isdn_data->q921)); } if (layer & 0x02) { stream->write_function(stream, "Q.931 loglevel: %s\n", Q931GetLogLevelName(&isdn_data->q931)); } stream->write_function(stream, "+OK"); } goto done; } #ifdef HAVE_PCAP else if (!strcasecmp(argv[0], "capture")) { ftdm_isdn_data_t *isdn_data = NULL; ftdm_span_t *span = NULL; int span_id = 0; /* capture [q931only] */ /* capture */ if (argc < 3) { stream->write_function(stream, "-ERR not enough arguments.\n"); goto done; } span_id = atoi(argv[1]); if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { isdn_data = span->signal_data; } else { stream->write_function(stream, "-ERR invalid span.\n"); goto done; } if (!strcasecmp(argv[2], "start")) { char *filename = NULL; if (argc < 4) { stream->write_function(stream, "-ERR not enough parameters.\n"); goto done; } if (isdn_pcap_is_open(isdn_data)) { stream->write_function(stream, "-ERR capture is already running.\n"); goto done; } filename = argv[3]; if (isdn_pcap_open(isdn_data, filename) != FTDM_SUCCESS) { stream->write_function(stream, "-ERR failed to open capture file.\n"); goto done; } if (argc > 4 && !strcasecmp(argv[4], "q931only")) { isdn_data->flags |= FTDM_ISDN_CAPTURE_L3ONLY; } isdn_pcap_start(isdn_data); stream->write_function(stream, "+OK capture started.\n"); goto done; } else if (!strcasecmp(argv[2], "stop")) { if (!isdn_pcap_is_open(isdn_data)) { stream->write_function(stream, "-ERR capture is not running.\n"); goto done; } isdn_pcap_stop(isdn_data); isdn_pcap_close(isdn_data); stream->write_function(stream, "+OK capture stopped.\n"); goto done; } else if (!strcasecmp(argv[2], "suspend")) { if (!isdn_pcap_is_open(isdn_data)) { stream->write_function(stream, "-ERR capture is not running.\n"); goto done; } isdn_pcap_stop(isdn_data); stream->write_function(stream, "+OK capture suspended.\n"); goto done; } else if (!strcasecmp(argv[2], "resume")) { if (!isdn_pcap_is_open(isdn_data)) { stream->write_function(stream, "-ERR capture is not running.\n"); goto done; } isdn_pcap_start(isdn_data); stream->write_function(stream, "+OK capture resumed.\n"); goto done; } else { stream->write_function(stream, "-ERR wrong action.\n"); goto done; } } #endif else { stream->write_function(stream, "-ERR invalid command.\n"); } done: ftdm_safe_free(mycmd); return FTDM_SUCCESS; } static int parse_mode(const char *mode) { if (!mode) return -1; if (!strcasecmp(mode, "user") || !strcasecmp(mode, "cpe")) { return Q931_TE; } if (!strcasecmp(mode, "net") || !strcasecmp(mode, "network")) { return Q931_NT; } return -1; } static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(isdn_configure_span) { Q931Dialect_t dialect = Q931_Dialect_National; ftdm_channel_t *dchan = NULL; ftdm_isdn_data_t *isdn_data; int32_t digit_timeout = 0; const char *tonemap = "us"; int dchan_count = 0, bchan_count = 0; int q921loglevel = -1; int q931loglevel = -1; uint32_t i; if (span->signal_type) { ftdm_log(FTDM_LOG_ERROR, "Span is already configured for signalling [%d]\n", span->signal_type); snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling [%d]", span->signal_type); return FTDM_FAIL; } if (ftdm_span_get_trunk_type(span) >= FTDM_TRUNK_NONE) { ftdm_log(FTDM_LOG_WARNING, "Invalid trunk type '%s' defaulting to T1\n", ftdm_span_get_trunk_type_str(span)); span->trunk_type = FTDM_TRUNK_T1; } for (i = 1; i <= ftdm_span_get_chan_count(span); i++) { ftdm_channel_t *chan = ftdm_span_get_channel(span, i); switch (ftdm_channel_get_type(chan)) { case FTDM_CHAN_TYPE_DQ921: if (dchan_count > 1) { ftdm_log(FTDM_LOG_ERROR, "Span has more than 1 D-Channel!\n"); snprintf(span->last_error, sizeof(span->last_error), "Span has more than 1 D-Channel!"); return FTDM_FAIL; } if (ftdm_channel_open(ftdm_span_get_id(span), i, &dchan) == FTDM_SUCCESS) { ftdm_log(FTDM_LOG_DEBUG, "opening d-channel #%d %d:%d\n", dchan_count, ftdm_channel_get_span_id(dchan), ftdm_channel_get_id(dchan)); dchan->state = FTDM_CHANNEL_STATE_UP; } dchan_count++; break; case FTDM_CHAN_TYPE_B: bchan_count++; break; default: break; } } if (!dchan_count) { ftdm_log(FTDM_LOG_ERROR, "Span has no D-Channel!\n"); snprintf(span->last_error, sizeof(span->last_error), "Span has no D-Channel!"); return FTDM_FAIL; } if (!bchan_count) { ftdm_log(FTDM_LOG_ERROR, "Span has no B-Channels!\n"); snprintf(span->last_error, sizeof(span->last_error), "Span has no B-Channels!"); return FTDM_FAIL; } isdn_data = malloc(sizeof(*isdn_data)); assert(isdn_data != NULL); memset(isdn_data, 0, sizeof(*isdn_data)); dialect = Q931_Dialect_Q931; /* Use trunk_mode span parameter to set default */ switch (ftdm_span_get_trunk_mode(span)) { case FTDM_TRUNK_MODE_NET: ftdm_log(FTDM_LOG_INFO, "Span '%s' [s%d] defaulting to NET mode\n", ftdm_span_get_name(span), ftdm_span_get_id(span)); isdn_data->mode = Q931_NT; break; default: ftdm_log(FTDM_LOG_INFO, "Span '%s' [s%d] defaulting to USER mode\n", ftdm_span_get_name(span), ftdm_span_get_id(span)); isdn_data->mode = Q931_TE; break; } for (i = 0; ftdm_parameters[i].var; i++) { const char *var = ftdm_parameters[i].var; const char *val = ftdm_parameters[i].val; if (ftdm_strlen_zero(var)) { ftdm_log(FTDM_LOG_WARNING, "Skipping variable with no name\n"); continue; } if (ftdm_strlen_zero(val)) { ftdm_log(FTDM_LOG_ERROR, "Variable '%s' has no value\n", var); return FTDM_FAIL; } if (!strcasecmp(var, "mode")) { if ((isdn_data->mode = parse_mode(val)) < 0) { ftdm_log(FTDM_LOG_ERROR, "Invalid/unknown mode '%s'\n", val); snprintf(span->last_error, sizeof(span->last_error), "Invalid/unknown mode [%s]!", val); return FTDM_FAIL; } } else if (!strcasecmp(var, "dialect")) { if (parse_dialect(val, &dialect) < 0) { ftdm_log(FTDM_LOG_ERROR, "Invalid/unknown dialect '%s'\n", val); snprintf(span->last_error, sizeof(span->last_error), "Invalid/unknown dialect [%s]!", val); return FTDM_FAIL; } } else if (!strcasecmp(var, "opts")) { if (parse_opts(val, &isdn_data->opts) < 0) { ftdm_log(FTDM_LOG_ERROR, "Invalid/unknown options '%s'\n", val); snprintf(span->last_error, sizeof(span->last_error), "Invalid/unknown options [%s]!", val); return FTDM_FAIL; } } else if (!strcasecmp(var, "tonemap")) { tonemap = (const char *)val; } else if (!strcasecmp(var, "digit_timeout")) { digit_timeout = atoi(val); if (digit_timeout < 3000 || digit_timeout > 30000) { ftdm_log(FTDM_LOG_WARNING, "Digit timeout %d ms outside of range (3000 - 30000 ms), using default (10000 ms)\n", digit_timeout); digit_timeout = DEFAULT_DIGIT_TIMEOUT; } } else if (!strcasecmp(var, "q921loglevel")) { if ((q921loglevel = parse_loglevel(val)) < 0) { ftdm_log(FTDM_LOG_ERROR, "Invalid/unknown loglevel '%s'\n", val); snprintf(span->last_error, sizeof(span->last_error), "Invalid/unknown loglevel [%s]!", val); return FTDM_FAIL; } } else if (!strcasecmp(var, "q931loglevel")) { if ((q931loglevel = parse_loglevel(val)) < 0) { ftdm_log(FTDM_LOG_ERROR, "Invalid/unknown loglevel '%s'\n", val); snprintf(span->last_error, sizeof(span->last_error), "Invalid/unknown loglevel [%s]!", val); return FTDM_FAIL; } } else { ftdm_log(FTDM_LOG_ERROR, "Unknown parameter '%s'\n", var); snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); return FTDM_FAIL; } } if (!digit_timeout) { digit_timeout = DEFAULT_DIGIT_TIMEOUT; } /* Check if modes match and log a message if they do not. Just to be on the safe side. */ if (isdn_data->mode == Q931_TE && ftdm_span_get_trunk_mode(span) == FTDM_TRUNK_MODE_NET) { ftdm_log(FTDM_LOG_WARNING, "Span '%s' signalling set up for TE/CPE/USER mode, while port is running in NT/NET mode. You may want to check your 'trunk_mode' settings.\n", ftdm_span_get_name(span)); } else if (isdn_data->mode == Q931_NT && ftdm_span_get_trunk_mode(span) == FTDM_TRUNK_MODE_CPE) { ftdm_log(FTDM_LOG_WARNING, "Span '%s' signalling set up for NT/NET mode, while port is running in TE/CPE/USER mode. You may want to check your 'trunk_mode' settings.\n", ftdm_span_get_name(span)); } /* allocate per b-chan data */ if (isdn_data->mode == Q931_NT) { ftdm_isdn_bchan_data_t *data; data = malloc(bchan_count * sizeof(ftdm_isdn_bchan_data_t)); if (!data) { return FTDM_FAIL; } for (i = 1; i <= ftdm_span_get_chan_count(span); i++, data++) { ftdm_channel_t *chan = ftdm_span_get_channel(span, i); if (ftdm_channel_get_type(chan) == FTDM_CHAN_TYPE_B) { chan->call_data = data; memset(data, 0, sizeof(ftdm_isdn_bchan_data_t)); } } } isdn_data->dchan = dchan; isdn_data->digit_timeout = digit_timeout; Q921_InitTrunk(&isdn_data->q921, 0, 0, isdn_data->mode, (ftdm_span_get_trunk_type(span) == FTDM_TRUNK_BRI_PTMP) ? Q921_PTMP : Q921_PTP, 0, ftdm_isdn_921_21, (Q921Tx23CB_t)ftdm_isdn_921_23, span, span); Q921SetLogCB(&isdn_data->q921, &ftdm_isdn_q921_log, span); Q921SetLogLevel(&isdn_data->q921, (Q921LogLevel_t)q921loglevel); Q931InitTrunk(&isdn_data->q931, dialect, isdn_data->mode, span->trunk_type, ftdm_isdn_931_34, (Q931Tx32CB_t)q931_rx_32, ftdm_isdn_931_err, span, span); Q931SetLogCB(&isdn_data->q931, &ftdm_isdn_q931_log, span); Q931SetLogLevel(&isdn_data->q931, (Q931LogLevel_t)q931loglevel); /* Register new event hander CB */ Q931SetCallEventCB(&isdn_data->q931, ftdm_isdn_call_event, span); /* TODO: hmm, maybe drop the "Trunk" prefix */ Q931TrunkSetAutoRestartAck(&isdn_data->q931, 1); Q931TrunkSetAutoConnectAck(&isdn_data->q931, 1); Q931TrunkSetAutoServiceAck(&isdn_data->q931, 1); Q931TrunkSetStatusEnquiry(&isdn_data->q931, 0); span->state_map = &isdn_state_map; span->signal_data = isdn_data; span->signal_type = FTDM_SIGTYPE_ISDN; span->signal_cb = sig_cb; span->start = ftdm_isdn_start; span->stop = ftdm_isdn_stop; span->outgoing_call = isdn_outgoing_call; span->get_channel_sig_status = isdn_get_channel_sig_status; span->get_span_sig_status = isdn_get_span_sig_status; #ifdef __TODO__ if ((isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL)) { span->channel_request = isdn_channel_request; span->flags |= FTDM_SPAN_SUGGEST_CHAN_ID; } #endif ftdm_span_load_tones(span, tonemap); return FTDM_SUCCESS; } /** * ISDN module io interface * \note This is really ugly... */ static ftdm_io_interface_t isdn_interface = { .name = "isdn", .api = isdn_api }; /** * \brief ISDN module io interface init callback */ static FIO_IO_LOAD_FUNCTION(isdn_io_load) { assert(fio != NULL); *fio = &isdn_interface; return FTDM_SUCCESS; } /** * \brief ISDN module load callback */ static FIO_SIG_LOAD_FUNCTION(isdn_load) { Q931Initialize(); Q921SetGetTimeCB(ftdm_time_now); Q931SetGetTimeCB(ftdm_time_now); return FTDM_SUCCESS; } /** * \brief ISDN module shutdown callback */ static FIO_SIG_UNLOAD_FUNCTION(isdn_unload) { return FTDM_SUCCESS; }; ftdm_module_t ftdm_module = { .name = "isdn", .io_load = isdn_io_load, .io_unload = NULL, .sig_load = isdn_load, .sig_unload = isdn_unload, .configure_span_signaling = isdn_configure_span }; /* For Emacs: * Local Variables: * mode:c * indent-tabs-mode:t * tab-width:4 * c-basic-offset:4 * End: * For VIM: * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet expandtab: */