FT_DECLARE(ftdm_status_t) ftdm_buffer_create(ftdm_buffer_t **buffer, ftdm_size_t blocksize, ftdm_size_t start_len, ftdm_size_t max_len) { ftdm_buffer_t *new_buffer; new_buffer = ftdm_malloc(sizeof(*new_buffer)); if (new_buffer) { memset(new_buffer, 0, sizeof(*new_buffer)); if (start_len) { new_buffer->data = ftdm_malloc(start_len); if (!new_buffer->data) { ftdm_safe_free(new_buffer); return FTDM_MEMERR; } memset(new_buffer->data, 0, start_len); } new_buffer->max_len = max_len; new_buffer->datalen = start_len; new_buffer->id = buffer_id++; new_buffer->blocksize = blocksize; new_buffer->head = new_buffer->data; *buffer = new_buffer; return FTDM_SUCCESS; } return FTDM_MEMERR; }
create_hashtable(unsigned int minsize, unsigned int (*hashf) (void*), int (*eqf) (void*,void*)) { struct hashtable *h; unsigned int pindex, size = primes[0]; /* Check requested hashtable isn't too large */ if (minsize > (1u << 30)) return NULL; /* Enforce size as prime */ for (pindex=0; pindex < prime_table_length; pindex++) { if (primes[pindex] > minsize) { size = primes[pindex]; break; } } h = (struct hashtable *)ftdm_malloc(sizeof(struct hashtable)); if (NULL == h) return NULL; /*oom*/ h->table = (struct entry **)ftdm_malloc(sizeof(struct entry*) * size); if (NULL == h->table) { ftdm_safe_free(h); return NULL; } /*oom*/ memset(h->table, 0, size * sizeof(struct entry *)); h->tablelength = size; h->primeindex = pindex; h->entrycount = 0; h->hashfn = hashf; h->eqfn = eqf; h->loadlimit = (unsigned int) ceil(size * max_load_factor); return h; }
void sngisdn_rcv_rst_cfm (int16_t suId, Rst *rstEvnt, int16_t dChan, uint8_t ces, uint8_t evntType) { unsigned i; sngisdn_span_data_t *signal_data; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); ftdm_log(FTDM_LOG_INFO, "Received RESTART CFM (dChan:%d ces:%u type:%u)\n", dChan, ces, evntType); /* Enqueue the event to each span within the dChan */ for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) { signal_data = g_sngisdn_data.dchans[dChan].spans[i]; sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_RST_CFM; sngisdn_event->suId = suId; sngisdn_event->dChan = dChan; sngisdn_event->ces = ces; sngisdn_event->evntType = evntType; sngisdn_event->signal_data = signal_data; memcpy(&sngisdn_event->event.rstEvnt, rstEvnt, sizeof(*rstEvnt)); ftdm_queue_enqueue((signal_data)->event_queue, sngisdn_event); } ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngisdn_rcv_srv_ind (int16_t suId, Srv *srvEvnt, int16_t dChan, uint8_t ces) { unsigned i; sngisdn_span_data_t *signal_data; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); ftdm_log(FTDM_LOG_INFO, "Received SERVICE IND (dChan:%d ces:%u)\n", dChan, ces); /* Enqueue the event to each span within the dChan */ for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) { signal_data = g_sngisdn_data.dchans[dChan].spans[i]; sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_SRV_IND; sngisdn_event->suId = suId; sngisdn_event->dChan = dChan; sngisdn_event->ces = ces; sngisdn_event->signal_data = signal_data; memcpy(&sngisdn_event->event.srvEvnt, srvEvnt, sizeof(*srvEvnt)); ftdm_queue_enqueue((signal_data)->event_queue, sngisdn_event); } ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngisdn_rcv_sta_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, StaEvnt *staEvnt) { sngisdn_chan_data_t *sngisdn_info; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) && !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) { ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId); ftdm_assert(0, "Inconsistent call states\n"); return; } ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received STATUS CONFIRM (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_STA_CFM; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->suInstId = suInstId; sngisdn_event->spInstId = spInstId; memcpy(&sngisdn_event->event.staEvnt, staEvnt, sizeof(*staEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngisdn_rcv_rel_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, RelEvnt *relEvnt) { sngisdn_chan_data_t *sngisdn_info = NULL; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) && !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) { ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId); /* It seems that Trillium has a bug where they sometimes send release twice on a call, so do not crash on these for now */ /* ftdm_assert(0, "Inconsistent call states\n"); */ return; } ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received RELEASE/RELEASE COMPLETE (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_REL_IND; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->suInstId = suInstId; sngisdn_event->spInstId = spInstId; memcpy(&sngisdn_event->event.relEvnt, relEvnt, sizeof(*relEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngisdn_trace_raw_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len) { uint8_t *raw_data; ftdm_sigmsg_t sigev; ftdm_channel_t *ftdmchan = NULL; sngisdn_frame_info_t frame_info; memset(&sigev, 0, sizeof(sigev)); /* Note: Mapped raw trace assume only exclusive b-channel selection is used. i.e the b-channel selected on outgoing SETUP is always used for the call */ if (sngisdn_get_frame_info(data, data_len, dir, &frame_info) == FTDM_SUCCESS) { if (sngisdn_map_call(signal_data, frame_info, &ftdmchan) == FTDM_SUCCESS) { sigev.call_id = ftdmchan->caller_data.call_id; sigev.span_id = ftdmchan->physical_span_id; sigev.chan_id = ftdmchan->physical_chan_id; sigev.channel = ftdmchan; } sigev.event_id = FTDM_SIGEVENT_TRACE_RAW; sigev.ev_data.trace.dir = dir; sigev.ev_data.trace.type = FTDM_TRACE_TYPE_Q931; raw_data = ftdm_malloc(data_len); ftdm_assert(raw_data, "Failed to malloc"); memcpy(raw_data, data, data_len); sigev.raw.data = raw_data; sigev.raw.len = data_len; sigev.raw.autofree = 1; ftdm_span_send_signal(signal_data->ftdm_span, &sigev); } }
void sngisdn_rcv_con_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, ConEvnt *conEvnt, int16_t dChan, uint8_t ces) { uint8_t bchan_no = 0; sngisdn_chan_data_t *sngisdn_info = NULL; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Con Ind on unconfigured cc\n"); ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Con Ind on unconfigured dchan\n"); if (conEvnt->chanId.eh.pres != PRSNT_NODEF) { /* TODO: Implement me */ ftdm_log(FTDM_LOG_ERROR, "Incoming call without Channel Id not supported yet\n"); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); return; } if (conEvnt->chanId.chanNmbSlotMap.pres) { bchan_no = conEvnt->chanId.chanNmbSlotMap.val[0]; } else if (conEvnt->chanId.infoChanSel.pres) { bchan_no = conEvnt->chanId.infoChanSel.val; } if (!bchan_no) { ftdm_log(FTDM_LOG_ERROR, "Failed to obtain b-channel number from SETUP message\n"); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); return; } if (g_sngisdn_data.dchans[dChan].channels[bchan_no] == NULL) { ftdm_log(FTDM_LOG_ERROR, "Incoming call on unconfigured b-channel:%d\n", bchan_no); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); return; } sngisdn_info = g_sngisdn_data.dchans[dChan].channels[bchan_no]; ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received SETUP (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_CON_IND; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->spInstId = spInstId; sngisdn_event->dChan = dChan; sngisdn_event->ces = ces; ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex); g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info; ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex); memcpy(&sngisdn_event->event.conEvnt, conEvnt, sizeof(*conEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
static int hashtable_expand(struct hashtable *h) { /* Double the size of the table to accomodate more entries */ struct entry **newtable; struct entry *e; struct entry **pE; unsigned int newsize, i, index; /* Check we're not hitting max capacity */ if (h->primeindex == (prime_table_length - 1)) return 0; newsize = primes[++(h->primeindex)]; newtable = (struct entry **)ftdm_malloc(sizeof(struct entry*) * newsize); if (NULL != newtable) { memset(newtable, 0, newsize * sizeof(struct entry *)); /* This algorithm is not 'stable'. ie. it reverses the list * when it transfers entries between the tables */ for (i = 0; i < h->tablelength; i++) { while (NULL != (e = h->table[i])) { h->table[i] = e->next; index = indexFor(newsize,e->h); e->next = newtable[index]; newtable[index] = e; } } ftdm_safe_free(h->table); h->table = newtable; } /* Plan B: realloc instead */ else { newtable = (struct entry **) realloc(h->table, newsize * sizeof(struct entry *)); if (NULL == newtable) { (h->primeindex)--; return 0; } h->table = newtable; memset(newtable[h->tablelength], 0, newsize - h->tablelength); for (i = 0; i < h->tablelength; i++) { for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) { index = indexFor(newsize,e->h); if (index == i) { pE = &(e->next); } else { *pE = e->next; e->next = newtable[index]; newtable[index] = e; } } } } h->tablelength = newsize; h->loadlimit = (unsigned int) ceil(newsize * max_load_factor); return -1; }
dsp_uart_handle_t *dsp_uart_create(dsp_uart_attr_t *attr) { dsp_uart_handle_t *handle; handle = ftdm_malloc(sizeof (*handle)); if (handle) { memset(handle, 0, sizeof (*handle)); /* fill the attributes member */ memcpy(&handle->attr, attr, sizeof (*attr)); } return handle; }
void sngisdn_rcv_cnst_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, CnStEvnt *cnStEvnt, uint8_t evntType, int16_t dChan, uint8_t ces) { sngisdn_chan_data_t *sngisdn_info = NULL; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Cnst Ind on unconfigured cc\n"); ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Cnst Ind on unconfigured dchan\n"); if (get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); return; } if (!sngisdn_info->spInstId) { ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex); sngisdn_info->spInstId = spInstId; g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info; ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex); } ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received %s (suId:%u suInstId:%u spInstId:%u ces:%d)\n", (evntType == MI_ALERTING)?"ALERT": (evntType == MI_CALLPROC)?"PROCEED": (evntType == MI_PROGRESS)?"PROGRESS": (evntType == MI_SETUPACK)?"SETUP ACK": (evntType == MI_NOTIFY)?"NOTIFY": (evntType == MI_INFO)?"INFO":"UNKNOWN", suId, suInstId, spInstId, ces); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_CNST_IND; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->suInstId = suInstId; sngisdn_event->spInstId = spInstId; sngisdn_event->dChan = dChan; sngisdn_event->ces = ces; sngisdn_event->evntType = evntType; memcpy(&sngisdn_event->event.cnStEvnt, cnStEvnt, sizeof(*cnStEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngss7_resm_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiResmEvnt *siResmEvnt) { SS7_FUNC_TRACE_ENTER(__FUNCTION__); sngss7_chan_data_t *sngss7_info = NULL; ftdm_channel_t *ftdmchan = NULL; sngss7_event_data_t *sngss7_event = NULL; if (g_ftdm_sngss7_data.cfg.isupCkt[circuit].type != SNG_CKT_VOICE) { SS7_ERROR("Rx sig event on circuit that is not a voice CIC (%d)\n", circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } /* get the ftdmchan and ss7_chan_data from the circuit */ if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) { SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } /* initalize the sngss7_event */ sngss7_event = ftdm_malloc(sizeof(*sngss7_event)); if (sngss7_event == NULL) { SS7_ERROR("Failed to allocate memory for sngss7_event!\n"); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } memset(sngss7_event, 0x0, sizeof(*sngss7_event)); /* fill in the sngss7_event struct */ sngss7_event->spInstId = spInstId; sngss7_event->suInstId = suInstId; sngss7_event->circuit = circuit; sngss7_event->event_id = SNGSS7_RESM_IND_EVENT; if (siResmEvnt != NULL) { memcpy(&sngss7_event->event.siResmEvnt, siResmEvnt, sizeof(*siResmEvnt)); } /* enqueue this event */ ftdm_queue_enqueue(((sngss7_span_data_t*)sngss7_info->ftdmchan->span->signal_data)->event_queue, sngss7_event); SS7_FUNC_TRACE_EXIT(__FUNCTION__); }
FT_DECLARE(ftdm_status_t) ftdm_thread_create_detached_ex(ftdm_thread_function_t func, void *data, ftdm_size_t stack_size) { ftdm_thread_t *thread = NULL; ftdm_status_t status = FTDM_FAIL; if (!func || !(thread = (ftdm_thread_t *)ftdm_malloc(sizeof(ftdm_thread_t)))) { goto done; } thread->private_data = data; thread->function = func; thread->stack_size = stack_size; #if defined(WIN32) thread->handle = (void *)_beginthreadex(NULL, (unsigned)thread->stack_size, (unsigned int (__stdcall *)(void *))thread_launch, thread, 0, NULL); if (!thread->handle) { goto fail; } CloseHandle(thread->handle); status = FTDM_SUCCESS; goto done; #else if (pthread_attr_init(&thread->attribute) != 0) goto fail; if (pthread_attr_setdetachstate(&thread->attribute, PTHREAD_CREATE_DETACHED) != 0) goto failpthread; if (thread->stack_size && pthread_attr_setstacksize(&thread->attribute, thread->stack_size) != 0) goto failpthread; if (pthread_create(&thread->handle, &thread->attribute, thread_launch, thread) != 0) goto failpthread; status = FTDM_SUCCESS; goto done; failpthread: pthread_attr_destroy(&thread->attribute); #endif fail: if (thread) { ftdm_safe_free(thread); } done: return status; }
void sngisdn_rcv_con_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, CnStEvnt *cnStEvnt, int16_t dChan, uint8_t ces) { sngisdn_chan_data_t *sngisdn_info = NULL; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Con Cfm on unconfigured cc\n"); ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Con Cfm on unconfigured dchan\n"); if (get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); return; } if (!sngisdn_info->spInstId) { ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex); sngisdn_info->spInstId = spInstId; g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info; ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex); } ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received CONNECT/CONNECT ACK (suId:%u suInstId:%u spInstId:%u ces:%d)\n", suId, suInstId, spInstId, ces); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_CON_CFM; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->suInstId = suInstId; sngisdn_event->spInstId = spInstId; sngisdn_event->dChan = dChan; sngisdn_event->ces = ces; memcpy(&sngisdn_event->event.cnStEvnt, cnStEvnt, sizeof(*cnStEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngss7_ssp_sta_cfm(uint32_t infId) { SS7_FUNC_TRACE_ENTER(__FUNCTION__); #if 0 sngss7_chan_data_t *sngss7_info = NULL; ftdm_channel_t *ftdmchan = NULL; sngss7_event_data_t *sngss7_event = NULL; /* get the ftdmchan and ss7_chan_data from the circuit */ if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) { SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } /* initalize the sngss7_event */ sngss7_event = ftdm_malloc(sizeof(*sngss7_event)); if (sngss7_event == NULL) { SS7_ERROR("Failed to allocate memory for sngss7_event!\n"); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } memset(sngss7_event, 0x0, sizeof(*sngss7_event)); /* fill in the sngss7_event struct */ sngss7_event->spInstId = spInstId; sngss7_event->suInstId = suInstId; sngss7_event->circuit = circuit; sngss7_event->event_id = SNGSS7_RESM_IND_EVENT; if (siSuspEvnt != NULL) { memcpy(&sngss7_event->event.siResmEvnt, siResmEvnt, sizeof(*siResmEvnt)); } /* enqueue this event */ ftdm_queue_enqueue(((sngss7_span_data_t*)sngss7_info->ftdmchan->span->signal_data)->event_queue, sngss7_event); #endif SS7_FUNC_TRACE_EXIT(__FUNCTION__); }
void sngisdn_trace_raw_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len) { uint8_t *raw_data; ftdm_sigmsg_t sigev; memset(&sigev, 0, sizeof(sigev)); sigev.span_id = signal_data->ftdm_span->span_id; sigev.chan_id = signal_data->dchan->chan_id; sigev.channel = signal_data->dchan; sigev.event_id = FTDM_SIGEVENT_TRACE_RAW; sigev.ev_data.trace.dir = dir; sigev.ev_data.trace.type = FTDM_TRACE_TYPE_Q921; raw_data = ftdm_malloc(data_len); ftdm_assert(raw_data, "Failed to malloc"); memcpy(raw_data, data, data_len); sigev.raw.data = raw_data; sigev.raw.len = data_len; ftdm_span_send_signal(signal_data->ftdm_span, &sigev); }
FT_DECLARE(ftdm_status_t) ftdm_mutex_create(ftdm_mutex_t **mutex) { ftdm_status_t status = FTDM_FAIL; #ifndef WIN32 pthread_mutexattr_t attr; #endif ftdm_mutex_t *check = NULL; check = (ftdm_mutex_t *)ftdm_malloc(sizeof(**mutex)); if (!check) goto done; #ifdef WIN32 InitializeCriticalSection(&check->mutex); #else if (pthread_mutexattr_init(&attr)) goto done; if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) goto fail; if (pthread_mutex_init(&check->mutex, &attr)) goto fail; goto success; fail: pthread_mutexattr_destroy(&attr); goto done; success: #endif *mutex = check; status = FTDM_SUCCESS; done: return status; }
void sngisdn_rcv_sta_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, StaEvnt *staEvnt) { sngisdn_chan_data_t *sngisdn_info; sngisdn_event_data_t *sngisdn_event = NULL; ISDN_FUNC_TRACE_ENTER(__FUNCTION__); /* We sometimes receive a STA CFM after receiving a RELEASE/RELEASE COMPLETE, so we need to lock here in case we are calling clear_call_data at the same time this function is called */ ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex); if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) && !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) { ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId); ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex); return; } ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received STATUS CONFIRM (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId); sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event)); ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n"); memset(sngisdn_event, 0, sizeof(*sngisdn_event)); sngisdn_event->event_id = SNGISDN_EVENT_STA_CFM; sngisdn_event->sngisdn_info = sngisdn_info; sngisdn_event->suId = suId; sngisdn_event->suInstId = suInstId; sngisdn_event->spInstId = spInstId; memcpy(&sngisdn_event->event.staEvnt, staEvnt, sizeof(*staEvnt)); ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event); ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex); ISDN_FUNC_TRACE_EXIT(__FUNCTION__); }
struct hashtable_itr * hashtable_iterator(struct hashtable *h) { unsigned int i, tablelength; struct hashtable_itr *itr = ftdm_malloc(sizeof(struct hashtable_itr)); if (NULL == itr) return NULL; itr->h = h; itr->e = NULL; itr->parent = NULL; tablelength = h->tablelength; itr->index = tablelength; if (0 == h->entrycount) return itr; for (i = 0; i < tablelength; i++) { if (NULL != h->table[i]) { itr->e = h->table[i]; itr->index = i; break; } } return itr; }
hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags) { /* This method allows duplicate keys - but they shouldn't be used */ unsigned int index; struct entry *e; if (++(h->entrycount) > h->loadlimit) { /* Ignore the return value. If expand fails, we should * still try cramming just this value into the existing table * -- we may not have memory for a larger table, but one more * element may be ok. Next time we insert, we'll try expanding again.*/ hashtable_expand(h); } e = (struct entry *)ftdm_malloc(sizeof(struct entry)); if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ e->h = hash(h,k); index = indexFor(h->tablelength,e->h); e->k = k; e->v = v; e->flags = flags; e->next = h->table[index]; h->table[index] = e; return -1; }
/* GENERAL STATUS *************************************************************/ void sngss7_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt) { SS7_FUNC_TRACE_ENTER(__FUNCTION__); sngss7_chan_data_t *sngss7_info = NULL; ftdm_channel_t *ftdmchan = NULL; sngss7_event_data_t *sngss7_event = NULL; uint32_t intfId; int x; /* check if the eventType is a pause/resume */ switch (evntType) { /**************************************************************************/ case (SIT_STA_PAUSEIND): case (SIT_STA_RESUMEIND): /* the circuit may or may not be on the local system so we have to find * circuit with the same intfId. The circuit specified might also be * a non-voice cic so we also need to find the first voice cic on this * system with the same intfId. */ intfId = g_ftdm_sngss7_data.cfg.isupCkt[circuit].infId; if (g_ftdm_sngss7_data.cfg.isupCkt[circuit].type != SNG_CKT_VOICE) { SS7_DEBUG("Rx %s on circuit that is not a voice CIC (%d) finding a new circuit\n", DECODE_LCC_EVENT(evntType), g_ftdm_sngss7_data.cfg.isupCkt[circuit].cic); } x = (g_ftdm_sngss7_data.cfg.procId * MAX_CIC_MAP_LENGTH) + 1; while ((g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) && (g_ftdm_sngss7_data.cfg.isupCkt[x].id < ((g_ftdm_sngss7_data.cfg.procId + 1) * MAX_CIC_MAP_LENGTH))) { /**********************************************************************/ /* confirm this is a voice channel and not a gap/sig (no ftdmchan there) */ if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == SNG_CKT_VOICE) { /* compare the intfIds */ if (g_ftdm_sngss7_data.cfg.isupCkt[x].infId == intfId) { /* we have a match, setup the pointers to the correct values */ circuit = x; /* confirm that the circuit is active on our side otherwise move to the next circuit */ if (!sngss7_test_flag(&g_ftdm_sngss7_data.cfg.isupCkt[circuit], SNGSS7_ACTIVE)) { SS7_DEBUG("[CIC:%d]Rx %s but circuit is not active yet, skipping!\n", g_ftdm_sngss7_data.cfg.isupCkt[circuit].cic, DECODE_LCC_EVENT(evntType)); x++; continue; } if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) { SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } /* bounce out of the loop */ break; } } x++; /**********************************************************************/ } /* check if we found any circuits that are on the intfId, drop the message * if none are found */ if (!ftdmchan) { SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } break; /**************************************************************************/ default: if (g_ftdm_sngss7_data.cfg.isupCkt[circuit].type != SNG_CKT_VOICE) { ftdm_log(FTDM_LOG_DEBUG, "Rx %s on circuit that is not a voice CIC (%d) (circuit:%d)\n", DECODE_LCC_EVENT(evntType), g_ftdm_sngss7_data.cfg.isupCkt[circuit].cic, circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } /* get the ftdmchan and ss7_chan_data from the circuit */ if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) { SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } break; /**************************************************************************/ } /* switch (evntType) */ /* initalize the sngss7_event */ sngss7_event = ftdm_malloc(sizeof(*sngss7_event)); if (sngss7_event == NULL) { SS7_ERROR("Failed to allocate memory for sngss7_event!\n"); SS7_FUNC_TRACE_EXIT(__FUNCTION__); return; } memset(sngss7_event, 0x0, sizeof(*sngss7_event)); /* fill in the sngss7_event struct */ sngss7_event->spInstId = spInstId; sngss7_event->suInstId = suInstId; sngss7_event->circuit = circuit; sngss7_event->globalFlg = globalFlg; sngss7_event->evntType = evntType; sngss7_event->event_id = SNGSS7_STA_IND_EVENT; if (siStaEvnt != NULL) { memcpy(&sngss7_event->event.siStaEvnt, siStaEvnt, sizeof(*siStaEvnt)); } /* enqueue this event */ ftdm_queue_enqueue(((sngss7_span_data_t*)sngss7_info->ftdmchan->span->signal_data)->event_queue, sngss7_event); }
void *on_wat_malloc(size_t size) { return ftdm_malloc(size); }